Update gpu_test_expectations to support OSX 10.11

src/common/string_utils.cpp

@@ -15,26 +15,53 @@
 namespace angle
 {
 
-void SplitString(const std::string &input,
-                 char delimiter,
-                 std::vector<std::string> *tokensOut)
+const char kWhitespaceASCII[] = " \f\n\r\t\v";
+
+std::vector<std::string> SplitString(const std::string &input,
+                                     const std::string &delimiters,
+                                     WhitespaceHandling whitespace,
+                                     SplitResult resultType)
 {
-    std::istringstream stream(input);
-    std::string token;
+    std::vector<std::string> result;
+    if (input.empty())
+    {
+        return result;
+    }
 
-    while (std::getline(stream, token, delimiter))
+    std::string::size_type start = 0;
+    while (start != std::string::npos)
     {
-        if (!token.empty())
+        auto end = input.find_first_of(delimiters, start);
+
+        std::string piece;
+        if (end == std::string::npos)
+        {
+            piece = input.substr(start);
+            start = std::string::npos;
+        }
+        else
+        {
+            piece = input.substr(start, end - start);
+            start = end + 1;
+        }
+
+        if (whitespace == TRIM_WHITESPACE)
         {
-            tokensOut->push_back(token);
+            piece = TrimString(piece, kWhitespaceASCII);
+        }
+
+        if (resultType == SPLIT_WANT_ALL || !piece.empty())
+        {
+            result.push_back(piece);
         }
     }
+
+    return result;
 }
 
 void SplitStringAlongWhitespace(const std::string &input,
                                 std::vector<std::string> *tokensOut)
 {
-    const char *delimiters = " \f\n\r\t\v";
 
     std::istringstream stream(input);
     std::string line;
@@ -42,7 +69,7 @@ void SplitStringAlongWhitespace(const std::string &input,
     while (std::getline(stream, line))
     {
         size_t prev = 0, pos;
-        while ((pos = line.find_first_of(delimiters, prev)) != std::string::npos)
+        while ((pos = line.find_first_of(kWhitespaceASCII, prev)) != std::string::npos)
         {
             if (pos > prev)
                 tokensOut->push_back(line.substr(prev, pos - prev));
@@ -53,6 +80,23 @@ void SplitStringAlongWhitespace(const std::string &input,
     }
 }
 
+std::string TrimString(const std::string &input, const std::string &trimChars)
+{
+    auto begin = input.find_first_not_of(trimChars);
+    if (begin == std::string::npos)
+    {
+        return "";
+    }
+
+    std::string::size_type end = input.find_last_not_of(trimChars);
+    if (end == std::string::npos)
+    {
+        return input.substr(begin);
+    }
+
+    return input.substr(begin, end - begin + 1);
+}
+
 bool HexStringToUInt(const std::string &input, unsigned int *uintOut)
 {
     unsigned int offset = 0;

src/common/string_utils.h

@@ -16,13 +16,30 @@
 namespace angle
 {
 
-void SplitString(const std::string &input,
-                 char delimiter,
-                 std::vector<std::string> *tokensOut);
+extern const char kWhitespaceASCII[];
+
+enum WhitespaceHandling
+{
+    KEEP_WHITESPACE,
+    TRIM_WHITESPACE,
+};
+
+enum SplitResult
+{
+    SPLIT_WANT_ALL,
+    SPLIT_WANT_NONEMPTY,
+};
+
+std::vector<std::string> SplitString(const std::string &input,
+                                     const std::string &delimiters,
+                                     WhitespaceHandling whitespace,
+                                     SplitResult resultType);
 
 void SplitStringAlongWhitespace(const std::string &input,
                                 std::vector<std::string> *tokensOut);
 
+std::string TrimString(const std::string &input, const std::string &trimChars);
+
 bool HexStringToUInt(const std::string &input, unsigned int *uintOut);
 
 bool ReadFileToString(const std::string &path, std::string *stringOut);

src/common/string_utils_unittest.cpp

@@ -16,34 +16,101 @@ using namespace angle;
 namespace
 {
 
-// Basic functionality tests for SplitString
-TEST(StringUtilsTest, SplitStringBasic)
+// Basic SplitString tests
+TEST(StringUtilsTest, SplitString_Basics)
 {
-    std::string testString("AxBxCxxxDExxFGHx");
-    std::vector<std::string> tokens;
-    SplitString(testString, 'x', &tokens);
-
-    ASSERT_EQ(5u, tokens.size());
-    EXPECT_EQ("A", tokens[0]);
-    EXPECT_EQ("B", tokens[1]);
-    EXPECT_EQ("C", tokens[2]);
-    EXPECT_EQ("DE", tokens[3]);
-    EXPECT_EQ("FGH", tokens[4]);
+    std::vector<std::string> r;
+
+    r = SplitString(std::string(), ",:;", KEEP_WHITESPACE, SPLIT_WANT_ALL);
+    EXPECT_TRUE(r.empty());
+
+    // Empty separator list
+    r = SplitString("hello, world", "", KEEP_WHITESPACE, SPLIT_WANT_ALL);
+    ASSERT_EQ(1u, r.size());
+    EXPECT_EQ("hello, world", r[0]);
+
+    // Should split on any of the separators.
+    r = SplitString("::,,;;", ",:;", KEEP_WHITESPACE, SPLIT_WANT_ALL);
+    ASSERT_EQ(7u, r.size());
+    for (auto str : r)
+        ASSERT_TRUE(str.empty());
+
+    r = SplitString("red, green; blue:", ",:;", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
+    ASSERT_EQ(3u, r.size());
+    EXPECT_EQ("red", r[0]);
+    EXPECT_EQ("green", r[1]);
+    EXPECT_EQ("blue", r[2]);
+
+    // Want to split a string along whitespace sequences.
+    r = SplitString("  red green   \tblue\n", " \t\n", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
+    ASSERT_EQ(3u, r.size());
+    EXPECT_EQ("red", r[0]);
+    EXPECT_EQ("green", r[1]);
+    EXPECT_EQ("blue", r[2]);
+
+    // Weird case of splitting on spaces but not trimming.
+    r = SplitString(" red ", " ", TRIM_WHITESPACE, SPLIT_WANT_ALL);
+    ASSERT_EQ(3u, r.size());
+    EXPECT_EQ("", r[0]);  // Before the first space.
+    EXPECT_EQ("red", r[1]);
+    EXPECT_EQ("", r[2]);  // After the last space.
 }
 
-// Basic functionality tests for SplitStringAlongWhitespace
-TEST(StringUtilsTest, SplitStringAlongWhitespaceBasic)
+// Check different whitespace and result types for SplitString
+TEST(StringUtilsTest, SplitString_WhitespaceAndResultType)
 {
-    std::string testString("A B\nC\r\tDE\v\fFGH \t\r\n");
-    std::vector<std::string> tokens;
-    SplitStringAlongWhitespace(testString, &tokens);
-
-    ASSERT_EQ(5u, tokens.size());
-    EXPECT_EQ("A", tokens[0]);
-    EXPECT_EQ("B", tokens[1]);
-    EXPECT_EQ("C", tokens[2]);
-    EXPECT_EQ("DE", tokens[3]);
-    EXPECT_EQ("FGH", tokens[4]);
+    std::vector<std::string> r;
+
+    // Empty input handling.
+    r = SplitString(std::string(), ",", KEEP_WHITESPACE, SPLIT_WANT_ALL);
+    EXPECT_TRUE(r.empty());
+    r = SplitString(std::string(), ",", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
+    EXPECT_TRUE(r.empty());
+
+    // Input string is space and we're trimming.
+    r = SplitString(" ", ",", TRIM_WHITESPACE, SPLIT_WANT_ALL);
+    ASSERT_EQ(1u, r.size());
+    EXPECT_EQ("", r[0]);
+    r = SplitString(" ", ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
+    EXPECT_TRUE(r.empty());
+
+    // Test all 4 combinations of flags on ", ,".
+    r = SplitString(", ,", ",", KEEP_WHITESPACE, SPLIT_WANT_ALL);
+    ASSERT_EQ(3u, r.size());
+    EXPECT_EQ("", r[0]);
+    EXPECT_EQ(" ", r[1]);
+    EXPECT_EQ("", r[2]);
+    r = SplitString(", ,", ",", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
+    ASSERT_EQ(1u, r.size());
+    ASSERT_EQ(" ", r[0]);
+    r = SplitString(", ,", ",", TRIM_WHITESPACE, SPLIT_WANT_ALL);
+    ASSERT_EQ(3u, r.size());
+    EXPECT_EQ("", r[0]);
+    EXPECT_EQ("", r[1]);
+    EXPECT_EQ("", r[2]);
+    r = SplitString(", ,", ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
+    ASSERT_TRUE(r.empty());
+}
+
+// Tests for TrimString
+TEST(StringUtilsTest, TrimString)
+{
+    // Basic tests
+    EXPECT_EQ("a", TrimString("a", kWhitespaceASCII));
+    EXPECT_EQ("a", TrimString(" a", kWhitespaceASCII));
+    EXPECT_EQ("a", TrimString("a ", kWhitespaceASCII));
+    EXPECT_EQ("a", TrimString(" a ", kWhitespaceASCII));
+
+    // Tests with empty strings
+    EXPECT_EQ("", TrimString("", kWhitespaceASCII));
+    EXPECT_EQ("", TrimString(" \n\r\t", kWhitespaceASCII));
+    EXPECT_EQ(" foo ", TrimString(" foo ", ""));
+
+    // Tests it doesn't removes characters in the middle
+    EXPECT_EQ("foo bar", TrimString(" foo bar ", kWhitespaceASCII));
+
+    // Test with non-whitespace trimChars
+    EXPECT_EQ(" ", TrimString("foo bar", "abcdefghijklmnopqrstuvwxyz"));
 }
 
 // Basic functionality tests for HexStringToUInt

src/tests/third_party/gpu_test_expectations/HowToMakeChanges.md

@@ -15,8 +15,8 @@ How to update from Chromium:
 
  * ```git apply -R angle-mods.patch```, ```git add . -u```, ```git commit```
  * Copy over Chromium files, ```git add . -u```, ```git commit```
- * ```git revert HEAD~2```
+ * ```git revert HEAD~```
  * ```rm angle-mods.patch```
- * ```git diff HEAD~1 (`)ls(`) > angle-mods.patch```,```git add angle-mods.patch```, ```git commit --amend```
+ * ```git diff HEAD~ (`)ls(`) > angle-mods.patch```,```git add angle-mods.patch```, ```git commit --amend```
  * ```git rebase -i``` to squash the three patches into one.
 

src/tests/third_party/gpu_test_expectations/angle_config.h

@@ -29,13 +29,18 @@ typedef uint32_t uint32;
 typedef int64_t int64;
 typedef uint64_t uint64;
 
-// Shim Chromium's base by importing functions in the bsae namespace.
+// Shim Chromium's base by importing functions in the base namespace.
 namespace base
 {
-    using angle::HexStringToUInt;
-    using angle::ReadFileToString;
+    using angle::kWhitespaceASCII;
+    using angle::TRIM_WHITESPACE;
+    using angle::KEEP_WHITESPACE;
+    using angle::SPLIT_WANT_ALL;
+    using angle::SPLIT_WANT_NONEMPTY;
     using angle::SplitString;
     using angle::SplitStringAlongWhitespace;
+    using angle::HexStringToUInt;
+    using angle::ReadFileToString;
 
     // StringPrintf is called differently in ANGLE but using cannot change
     // the name of the imported function. Use a define to change the name.

src/tests/third_party/gpu_test_expectations/gpu_info.cc

@@ -40,8 +40,10 @@ GPUInfo::GPUInfo()
       direct_rendering(true),
       sandboxed(false),
       process_crash_count(0),
+      in_process_gpu(true),
       basic_info_state(kCollectInfoNone),
-      context_info_state(kCollectInfoNone) {
+      context_info_state(kCollectInfoNone),
+      jpeg_decode_accelerator_supported(false) {
 }
 
 GPUInfo::~GPUInfo() { }
@@ -75,8 +77,10 @@ void GPUInfo::EnumerateFields(Enumerator* enumerator) const {
     bool direct_rendering;
     bool sandboxed;
     int process_crash_count;
+    bool in_process_gpu;
     CollectInfoResult basic_info_state;
     CollectInfoResult context_info_state;
+    bool jpeg_decode_accelerator_supported;
   };
 
   // If this assert fails then most likely something below needs to be updated.
@@ -120,8 +124,12 @@ void GPUInfo::EnumerateFields(Enumerator* enumerator) const {
   enumerator->AddBool("directRendering", direct_rendering);
   enumerator->AddBool("sandboxed", sandboxed);
   enumerator->AddInt("processCrashCount", process_crash_count);
+  enumerator->AddBool("inProcessGpu", in_process_gpu);
   enumerator->AddInt("basicInfoState", basic_info_state);
   enumerator->AddInt("contextInfoState", context_info_state);
+  // TODO(kbr): add dx_diagnostics on Windows.
+  enumerator->AddBool("jpegDecodeAcceleratorSupported",
+      jpeg_decode_accelerator_supported);
   enumerator->EndAuxAttributes();
 }
 

src/tests/third_party/gpu_test_expectations/gpu_info.h

@@ -173,11 +173,16 @@ struct GPU_EXPORT GPUInfo {
   // Number of GPU process crashes recorded.
   int process_crash_count;
 
+  // True if the GPU is running in the browser process instead of its own.
+  bool in_process_gpu;
+
   // The state of whether the basic/context/DxDiagnostics info is collected and
   // if the collection fails or not.
   CollectInfoResult basic_info_state;
   CollectInfoResult context_info_state;
 
+  bool jpeg_decode_accelerator_supported;
+
   // Note: when adding new members, please remember to update EnumerateFields
   // in gpu_info.cc.
 

src/tests/third_party/gpu_test_expectations/gpu_test_config.cc

@@ -236,6 +236,8 @@ GPUTestConfig::OS GetCurrentOS() {
         return GPUTestConfig::kOsMacMavericks;
       case 10:
         return GPUTestConfig::kOsMacYosemite;
+      case 11:
+        return GPUTestConfig::kOsMacElCapitan;
     }
   }
 #elif defined(OS_ANDROID)
@@ -358,6 +360,7 @@ bool GPUTestBotConfig::IsValid() const {
     case kOsMacMountainLion:
     case kOsMacMavericks:
     case kOsMacYosemite:
+    case kOsMacElCapitan:
     case kOsLinux:
     case kOsChromeOS:
     case kOsAndroid:

src/tests/third_party/gpu_test_expectations/gpu_test_config.h

@@ -28,12 +28,14 @@ class GPU_EXPORT GPUTestConfig {
     kOsMacMountainLion = 1 << 7,
     kOsMacMavericks = 1 << 8,
     kOsMacYosemite = 1 << 9,
+    kOsMacElCapitan = 1 << 10,
     kOsMac = kOsMacLeopard | kOsMacSnowLeopard | kOsMacLion |
-             kOsMacMountainLion | kOsMacMavericks | kOsMacYosemite,
-    kOsLinux = 1 << 10,
-    kOsChromeOS = 1 << 11,
-    kOsAndroid = 1 << 12,
-    kOsWin10 = 1 << 13,
+             kOsMacMountainLion | kOsMacMavericks | kOsMacYosemite |
+             kOsMacElCapitan,
+    kOsLinux = 1 << 11,
+    kOsChromeOS = 1 << 12,
+    kOsAndroid = 1 << 13,
+    kOsWin10 = 1 << 14,
     kOsWin = kOsWinXP | kOsWinVista | kOsWin7 | kOsWin8 | kOsWin10,
   };
 

src/tests/third_party/gpu_test_expectations/gpu_test_expectations_parser.cc

@@ -68,6 +68,7 @@ enum Token {
   kConfigMacMountainLion,
   kConfigMacMavericks,
   kConfigMacYosemite,
+  kConfigMacElCapitan,
   kConfigMac,
   kConfigLinux,
   kConfigChromeOS,
@@ -121,6 +122,7 @@ const TokenInfo kTokenData[] = {
     {"mountainlion", GPUTestConfig::kOsMacMountainLion},
     {"mavericks", GPUTestConfig::kOsMacMavericks},
     {"yosemite", GPUTestConfig::kOsMacYosemite},
+    {"elcapitan", GPUTestConfig::kOsMacElCapitan},
     {"mac", GPUTestConfig::kOsMac},
     {"linux", GPUTestConfig::kOsLinux},
     {"chromeos", GPUTestConfig::kOsChromeOS},
@@ -216,8 +218,8 @@ bool GPUTestExpectationsParser::LoadTestExpectations(const std::string& data) {
   entries_.clear();
   error_messages_.clear();
 
-  std::vector<std::string> lines;
-  base::SplitString(data, '\n', &lines);
+  std::vector<std::string> lines = base::SplitString(
+      data, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   bool rt = true;
   for (size_t i = 0; i < lines.size(); ++i) {
     if (!ParseLine(lines[i], i + 1))
@@ -263,8 +265,9 @@ GPUTestExpectationsParser::GetErrorMessages() const {
 bool GPUTestExpectationsParser::ParseConfig(
     const std::string& config_data, GPUTestConfig* config) {
   DCHECK(config);
-  std::vector<std::string> tokens;
-  base::SplitStringAlongWhitespace(config_data, &tokens);
+  std::vector<std::string> tokens = base::SplitString(
+      config_data, base::kWhitespaceASCII, base::KEEP_WHITESPACE,
+      base::SPLIT_WANT_NONEMPTY);
 
   for (size_t i = 0; i < tokens.size(); ++i) {
     Token token = ParseToken(tokens[i]);
@@ -281,6 +284,7 @@ bool GPUTestExpectationsParser::ParseConfig(
       case kConfigMacMountainLion:
       case kConfigMacMavericks:
       case kConfigMacYosemite:
+      case kConfigMacElCapitan:
       case kConfigMac:
       case kConfigLinux:
       case kConfigChromeOS:
@@ -313,8 +317,9 @@ bool GPUTestExpectationsParser::ParseConfig(
 
 bool GPUTestExpectationsParser::ParseLine(
     const std::string& line_data, size_t line_number) {
-  std::vector<std::string> tokens;
-  base::SplitStringAlongWhitespace(line_data, &tokens);
+  std::vector<std::string> tokens = base::SplitString(
+      line_data, base::kWhitespaceASCII, base::KEEP_WHITESPACE,
+      base::SPLIT_WANT_NONEMPTY);
   int32 stage = kLineParserBegin;
   GPUTestExpectationEntry entry;
   entry.line_number = line_number;
@@ -338,6 +343,7 @@ bool GPUTestExpectationsParser::ParseLine(
       case kConfigMacMountainLion:
       case kConfigMacMavericks:
       case kConfigMacYosemite:
+      case kConfigMacElCapitan:
       case kConfigMac:
       case kConfigLinux:
       case kConfigChromeOS:
@@ -458,6 +464,7 @@ bool GPUTestExpectationsParser::UpdateTestConfig(
     case kConfigMacMountainLion:
     case kConfigMacMavericks:
     case kConfigMacYosemite:
+    case kConfigMacElCapitan:
     case kConfigMac:
     case kConfigLinux:
     case kConfigChromeOS: