Quirks Client for downloading and providing display profiles

chrome/browser/chromeos/display/quirks_browsertest.cc

Index: chrome/browser/chromeos/display/quirks_browsertest.cc
diff --git a/chrome/browser/chromeos/display/quirks_browsertest.cc b/chrome/browser/chromeos/display/quirks_browsertest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4a74dd77133755ea79f73c2fb0178bcfbf2b27a3
--- /dev/null
+++ b/chrome/browser/chromeos/display/quirks_browsertest.cc
@@ -0,0 +1,143 @@
+// 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/files/file_util.h"
+#include "base/run_loop.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "components/quirks/quirks_manager.h"
+#include "components/quirks/switches.h"
+#include "content/public/test/test_utils.h"
+#include "net/url_request/test_url_fetcher_factory.h"
+
+namespace quirks {
+
+namespace {
+
+base::Closure g_EndMessageLoop;  // Callback to terminate msg loop.
+base::FilePath g_icc_path;       // Path to icc file if found or downloaded.

[stevenjb, 2016/02/17 23:38:54]

I am going to focus on the non test code for this pass, but we should be able to
test this without resorting to using file local variables (which should be named
s_foo_bar btw).

+
+const char kFakeIccJson[] = "{\n  \"icc\": \"AAAIkCAgICACEAAA\"\n}";
+const char kFakeIccData[] = {0x00, 0x00, 0x08, 0x90, 0x20, 0x20,
+                             0x20, 0x20, 0x02, 0x10, 0x00, 0x00};
+
+// Create FakeURLFetcher which returns fake icc file json.
+scoped_ptr<net::URLFetcher> CreateFakeURLFetcherSuccess(
+    const GURL& url,
+    net::URLFetcherDelegate* delegate) {
+  net::URLFetcher* fetcher =
+      new net::FakeURLFetcher(url, delegate, kFakeIccJson, net::HTTP_OK,
+                              net::URLRequestStatus::SUCCESS);
+  return make_scoped_ptr(fetcher);
+}
+
+// Create FakeURLFetcher which replies with HTTP_NOT_FOUND.
+scoped_ptr<net::URLFetcher> CreateFakeURLFetcherFailure(
+    const GURL& url,
+    net::URLFetcherDelegate* delegate) {
+  net::URLFetcher* fetcher = new net::FakeURLFetcher(
+      url, delegate, "File not found", net::HTTP_NOT_FOUND,
+      net::URLRequestStatus::FAILED);
+  return make_scoped_ptr(fetcher);
+}
+
+// Full path to fake icc file in <tmp test directory>/display_profiles/.
+base::FilePath GetPathForIccFile(int64_t product_id) {
+  return QuirksManager::Get()->delegate()->GetDisplayProfileDirectory().Append(
+      quirks::IdToHexString(product_id).append(".icc"));
+}
+
+void OnQuirksClientFinished(const base::FilePath& path) {
+  g_icc_path = path;
+  ASSERT_TRUE(!g_EndMessageLoop.is_null());
+  g_EndMessageLoop.Run();
+}
+
+void RunQuirksClientOnBlockingPool(int64_t product_id, bool expect_exists) {
+  base::FilePath icc_path = quirks::RequestIccProfilePath(
+      product_id, base::Bind(&OnQuirksClientFinished));
+  bool exists = !icc_path.empty();
+  EXPECT_EQ(expect_exists, exists);
+
+  // If path not empty, icc file already existed, and we're done waiting.
+  if (exists) {
+    g_icc_path = icc_path;
+    ASSERT_TRUE(!g_EndMessageLoop.is_null());
+    QuirksManager::Get()->task_runner()->PostTask(FROM_HERE, g_EndMessageLoop);

[Greg Levin, 2016/02/17 23:01:51]

Is there a better way to do this?

+  }
+}
+
+}  // namespace
+
+class QuirksBrowserTest : public InProcessBrowserTest {
+ public:
+  QuirksBrowserTest() = default;
+
+ protected:
+  ~QuirksBrowserTest() override = default;
+
+  void Initialize() {
+    // NOTE: QuirksManager::Initialize() isn't necessary here, since it'll be
+    // called in ChromeBrowserMainPartsChromeos::PreMainMessageLoopRun().
+
+    // Create display_profiles subdirectory under tmp profile dir.
+    const base::FilePath path =
+        QuirksManager::Get()->delegate()->GetDisplayProfileDirectory();
+    base::File::Error error = base::File::FILE_OK;
+    bool created = base::CreateDirectoryAndGetError(path, &error);
+    ASSERT_TRUE(created);
+  }
+
+  // Runs Quirks Client on file thread, then waits till it's done.
+  // |find_fake_file| indicates that URLFetcher should respond with success.
+  // |expect_exists| indicates that the file should have already been created.
+  void TestQuirksClient(int64_t product_id,
+                        bool find_fake_file,
+                        bool expect_exists) {
+    // Set up fake url getter
+    QuirksManager::Get()->SetFakeQuirksFetcherCreatorForTests(
+        base::Bind(find_fake_file ? &CreateFakeURLFetcherSuccess
+                                  : &CreateFakeURLFetcherFailure));
+
+    base::RunLoop run_loop;
+    g_EndMessageLoop = run_loop.QuitClosure();
+
+    g_icc_path.clear();
+    content::BrowserThread::GetBlockingPool()->PostTask(
+        FROM_HERE,
+        base::Bind(&RunQuirksClientOnBlockingPool, product_id, expect_exists));
+
+    run_loop.Run();
+  }
+
+  // InProcessBrowserTest overrides.
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    command_line->AppendSwitch(switches::kEnableDisplayQuirksClient);
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(QuirksBrowserTest, DownloadIccFile) {
+  Initialize();
+
+  // Request a file from fake Quirks Server, verify that file is written with
+  // correct location and data.
+  TestQuirksClient(0x0000aaaa, true, false);
+  base::FilePath path = GetPathForIccFile(0x0000aaaa);
+  EXPECT_EQ(g_icc_path, path);
+  EXPECT_TRUE(base::PathExists(path));
+  char data[32];
+  ReadFile(path, data, sizeof(data));
+  EXPECT_EQ(0, memcmp(data, kFakeIccData, sizeof(kFakeIccData)));
+
+  // Retest same file, this time expect it to already exist.
+  TestQuirksClient(0x0000aaaa, true, true);
+  EXPECT_EQ(g_icc_path, path);
+
+  // Finally, request a file that doesn't exist on fake Quirks Server.
+  TestQuirksClient(0x1111bbbb, false, false);
+  EXPECT_EQ(g_icc_path, base::FilePath());
+  EXPECT_FALSE(base::PathExists(GetPathForIccFile(0x1111bbbb)));
+}
+
+}  // namespace quirks