Shape Detection: Implement FaceDetection on Mac as out-of-process service

content/browser/shapedetection/shapedetection_browsertest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/command_line.h"
 #include "base/strings/string_tokenizer.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 
 namespace content {
 
-// TODO(xianglu): Enable other platforms with support. https://crbug.com/646083
-#if defined(OS_ANDROID)
+// TODO(xianglu): Enable other platforms support. https://crbug.com/646083
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
 #define MAYBE_ShapeDetectionBrowserTest ShapeDetectionBrowserTest
 #else
 #define MAYBE_ShapeDetectionBrowserTest DISABLED_ShapeDetectionBrowserTest
 #endif
 
 namespace {
 
 const char kFaceDetectionTestHtml[] = "/media/face_detection_test.html";
 
 }  // namespace
 
 // This class contains content_browsertests for Shape Detection API, which
-// allows for generating bounding boxes for faces on still images..
+// allows for generating bounding boxes in still images..
 class MAYBE_ShapeDetectionBrowserTest : public ContentBrowserTest {
  public:
   void SetUpCommandLine(base::CommandLine* command_line) override {
-    // Specific flag to enable ShapeDetection and DOMRect API.
+    // Flag to enable ShapeDetection and DOMRect API.
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kEnableBlinkFeatures, "ShapeDetection, GeometryInterfaces");
   }
 
  protected:
   void RunDetectFacesOnImageUrl(
       const std::string& image_path,
       const std::vector<std::vector<float>>& expected_results) {
     ASSERT_TRUE(embedded_test_server()->Start());
 
     const GURL html_url(embedded_test_server()->GetURL(kFaceDetectionTestHtml));
     const GURL image_url(embedded_test_server()->GetURL(image_path));
     NavigateToURL(shell(), html_url);
     const std::string js_command =
         "detectFacesOnImageUrl('" + image_url.spec() + "')";
     std::string response_string;
     ASSERT_TRUE(
         ExecuteScriptAndExtractString(shell(), js_command, &response_string));
 
     base::StringTokenizer outer_tokenizer(response_string, "#");
     std::vector<std::vector<float>> results;
     while (outer_tokenizer.GetNext()) {
       std::string s = outer_tokenizer.token().c_str();
       std::vector<float> res;
       base::StringTokenizer inner_tokenizer(s, ",");
       while (inner_tokenizer.GetNext())
         res.push_back(atof(inner_tokenizer.token().c_str()));
       results.push_back(res);
     }
+    ASSERT_EQ(expected_results.size(), results.size()) << "Number of faces";
 
-    ASSERT_EQ(expected_results.size(), results.size()) << "Number of faces";
     for (size_t face_id = 0; face_id < results.size(); ++face_id) {
       const std::vector<float> expected_result = expected_results[face_id];
       const std::vector<float> result = results[face_id];
       for (size_t i = 0; i < 4; ++i)
-        EXPECT_NEAR(expected_result[i], result[i], 0.1) << "At index " << i;
+        EXPECT_NEAR(expected_result[i], result[i], 2) << "At index " << i;
     }
   }
 };
 
 IN_PROC_BROWSER_TEST_F(MAYBE_ShapeDetectionBrowserTest,
                        DetectFacesOnImageWithNoFaces) {
   const std::string image_path = "/blank.jpg";
   const std::vector<std::vector<float>> expected_empty_results;
   RunDetectFacesOnImageUrl(image_path, expected_empty_results);
 }
 
 IN_PROC_BROWSER_TEST_F(MAYBE_ShapeDetectionBrowserTest,
                        DetectFacesOnImageWithOneFace) {
   const std::string image_path = "/single_face.jpg";
+  std::vector<std::vector<float>> expected_results;
+#if defined(OS_ANDROID)
   const std::vector<float> expected_result = {68.640625, 102.96875, 171.5625,
                                               171.5625};
-  const std::vector<std::vector<float>> expected_results = {expected_result};
+  expected_results.push_back(expected_result);
+#elif defined(OS_MACOSX)
+  const std::vector<float> expected_result = {0, 93, 290, 290};
+  expected_results.push_back(expected_result);
+#endif
+
   RunDetectFacesOnImageUrl(image_path, expected_results);
 }
 
 }  // namespace content