Quirks Client for downloading and providing display profiles

components/quirks/quirks_manager.cc

Index: components/quirks/quirks_manager.cc
diff --git a/components/quirks/quirks_manager.cc b/components/quirks/quirks_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3f24f89632f5268b7f13cc3bc7dbad242f3d1af3
--- /dev/null
+++ b/components/quirks/quirks_manager.cc
@@ -0,0 +1,253 @@
+// 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 "components/quirks/quirks_manager.h"
+
+#include "base/command_line.h"
+#include "base/files/file_util.h"
+#include "base/format_macros.h"
+#include "base/path_service.h"
+#include "base/rand_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/task_runner_util.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/threading/thread_restrictions.h"
+#include "components/prefs/pref_registry_simple.h"
+#include "components/prefs/scoped_user_pref_update.h"
+#include "components/quirks/pref_names.h"
+#include "components/quirks/switches.h"
+#include "net/url_request/url_fetcher.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "url/gurl.h"
+
+namespace quirks {
+
+namespace {
+
+QuirksManager* g_manager = nullptr;
+
+const char kIccExtension[] = ".icc";
+
+// How often we query Quirks Server.
+const int kDaysBetweenServerChecks = 30;
+
+// Check if file exists, VLOG results.
+bool CheckAndLogFile(const base::FilePath& path) {
+  base::ThreadRestrictions::AssertIOAllowed();
+  const bool exists = base::PathExists(path);
+  VLOG(1) << (exists ? "File" : "No File") << " found at " << path.value();
+  // TODO(glevin): If file exists, do we want to implement a hash to verify that
+  // the file hasn't been corrupted or tampered with?
+  return exists;
+}
+
+base::FilePath CheckForIccFile(base::FilePath built_in_path,
+                               base::FilePath download_path) {
+  // First, look for icc file in old read-only location.  If there, we don't use
+  // the Quirks server.
+  // TODO(glevin): Awaiting final decision on how to handle old read-only files.
+  if (CheckAndLogFile(built_in_path))
+    return built_in_path;
+
+  // If experimental Quirks flag isn't set, no other icc file is available.
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableDisplayQuirksClient)) {
+    VLOG(1) << "Quirks Client disabled, no built-in icc file available.";
+    return base::FilePath();
+  }
+
+  // Check if QuirksClient has already downloaded icc file from server.
+  if (CheckAndLogFile(download_path))
+    return download_path;
+
+  return base::FilePath();
+}
+
+}  // namespace
+
+std::string IdToHexString(int64_t product_id) {
+  return base::StringPrintf("%08" PRIx64, product_id);
+}
+
+std::string IdToFileName(int64_t product_id) {
+  return IdToHexString(product_id).append(kIccExtension);
+}
+
+void RequestIccProfilePath(int64_t product_id,
+                           const RequestFinishedCallback& on_request_finished) {
+  if (g_manager)
+    g_manager->RequestIccFilePath(product_id, on_request_finished);
+  else
+    LOG(ERROR) << "Quirks Client Manager not initialized; can't get icc file.";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// QuirksManager
+
+QuirksManager::QuirksManager(
+    Delegate* delegate,
+    scoped_refptr<base::SequencedWorkerPool> blocking_pool,
+    PrefService* local_state,
+    scoped_refptr<net::URLRequestContextGetter> url_context_getter)
+    : delegate_(delegate),
+      blocking_pool_(blocking_pool),
+      local_state_(local_state),
+      url_context_getter_(url_context_getter),
+      weak_ptr_factory_(this) {}
+
+QuirksManager::~QuirksManager() {
+  clients_.clear();
+  g_manager = nullptr;
+}
+
+// static
+void QuirksManager::Initialize(
+    scoped_ptr<Delegate> delegate,
+    scoped_refptr<base::SequencedWorkerPool> blocking_pool,
+    PrefService* local_state,
+    scoped_refptr<net::URLRequestContextGetter> url_context_getter) {
+  g_manager = new QuirksManager(delegate.release(), blocking_pool, local_state,

[stevenjb, 2016/03/08 22:38:06]

Pass this to QuirksManager() as a scoped_ptr to make the ownership transfer more
clear.

[Greg Levin, 2016/03/09 22:46:16]

Done.

+                                url_context_getter);
+}
+
+// static
+void QuirksManager::Shutdown() {
+  delete g_manager;
+}
+
+// static
+QuirksManager* QuirksManager::Get() {
+  DCHECK(g_manager);
+  return g_manager;
+}
+
+// static
+void QuirksManager::RegisterPrefs(PrefRegistrySimple* registry) {
+  registry->RegisterDictionaryPref(prefs::kQuirksClientLastServerCheck);
+}
+
+void QuirksManager::RequestIccFilePath(
+    int64_t product_id,
+    const RequestFinishedCallback& on_request_finished) {
+  DCHECK(base::ThreadTaskRunnerHandle::IsSet());
+
+  std::string name = IdToFileName(product_id);
+  base::PostTaskAndReplyWithResult(
+      blocking_pool_.get(), FROM_HERE,
+      base::Bind(&CheckForIccFile,
+                 delegate_->GetBuiltInDisplayProfileDirectory().Append(name),
+                 delegate_->GetDownloadDisplayProfileDirectory().Append(name)),
+      base::Bind(&QuirksManager::OnIccFilePathRequestCompleted,
+                 weak_ptr_factory_.GetWeakPtr(), product_id,
+                 on_request_finished));
+}
+
+void QuirksManager::ClientFinished(QuirksClient* client) {
+  SetLastServerCheck(client->product_id(), base::Time::Now());
+  auto it = std::find_if(clients_.begin(), clients_.end(),
+                         [client](const scoped_ptr<QuirksClient>& c) {
+                           return c.get() == client;
+                         });
+  CHECK(it != clients_.end());
+  clients_.erase(it);
+}
+
+// TODO(glevin): Add code to record UMA stats here.  Also need to set
+// request_reason_ in QuirksClient.
+void QuirksManager::RecordReasonUmaStat(QuirksClient::RequestReason reason) {}
+
+void QuirksManager::RecordFileFoundUmaStat(bool success) {}
+
+scoped_ptr<net::URLFetcher> QuirksManager::CreateURLFetcher(
+    const std::string& url,
+    net::URLFetcherDelegate* delegate) {
+  if (!fake_quirks_fetcher_creator_.is_null())
+    return fake_quirks_fetcher_creator_.Run(GURL(url), delegate);
+
+  return net::URLFetcher::Create(GURL(url), net::URLFetcher::GET, delegate);
+}
+
+void QuirksManager::OnIccFilePathRequestCompleted(
+    int64_t product_id,
+    const RequestFinishedCallback& on_request_finished,
+    base::FilePath path) {
+  DCHECK(base::ThreadTaskRunnerHandle::IsSet());
+
+  // If we found a file or client is disabled, inform requester.
+  if (!path.empty() ||
+      !base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableDisplayQuirksClient)) {
+    on_request_finished.Run(path, false);
+    // TODO(glevin): Eventually we'll want to check the server for updates even

[stevenjb, 2016/03/08 22:38:06]

nit: s/Eventually we'll want to check/Check/

[Greg Levin, 2016/03/09 22:46:16]

Done.

+    // if the file exists.
+    return;
+  }
+
+  double last_check = 0.0;
+  local_state_->GetDictionary(prefs::kQuirksClientLastServerCheck)
+      ->GetDouble(IdToHexString(product_id), &last_check);
+
+  // If never checked server before, need to check for new device.
+  if (last_check == 0.0) {
+    delegate_->GetDaysSinceOobe(
+        blocking_pool_, base::Bind(&QuirksManager::OnDaysSinceOobeGotten,

[stevenjb, 2016/03/08 22:38:06]

nit: "Gotten"? Perhaps just "OnGetDaysSinceOob". (or 'RequestDays...' +
'OnDays...Received').

[Greg Levin, 2016/03/09 22:46:16]

Gotten is a perfectly cromulent word. But ok, went with
OnDaysSinceOobeReceived() (the present tense versions just didn't sound right
:-P)

+                                   weak_ptr_factory_.GetWeakPtr(), product_id,
+                                   on_request_finished));
+    return;
+  }
+
+  const base::TimeDelta time_since =
+      base::Time::Now() - base::Time::FromDoubleT(last_check);
+
+  // Don't need server check if we've checked within last 30 days.
+  if (time_since < base::TimeDelta::FromDays(kDaysBetweenServerChecks)) {
+    VLOG(2) << time_since.InDays()
+            << " days since last Quirks Server check for display "
+            << IdToHexString(product_id);
+    on_request_finished.Run(base::FilePath(), false);
+    return;
+  }
+
+  RunClient(product_id, on_request_finished);
+}
+
+void QuirksManager::OnDaysSinceOobeGotten(
+    int64_t product_id,
+    const RequestFinishedCallback& on_request_finished,
+    int days_since_oobe) {
+  // On new devices, we want to check server immediately.
+  if (days_since_oobe <= kDaysBetweenServerChecks) {
+    RunClient(product_id, on_request_finished);
+    return;
+  }
+
+  // Otherwise, for the first check on an older device, we want to stagger
+  // it over 30 days, so artificially set last check accordingly.
+  const int rand_days = base::RandInt(0, kDaysBetweenServerChecks);
+  const base::Time fake_last_check =
+      base::Time::Now() - base::TimeDelta::FromDays(rand_days);
+  SetLastServerCheck(product_id, fake_last_check);
+  VLOG(2) << "Delaying first Quirks Server check by "
+          << kDaysBetweenServerChecks - rand_days << " days.";
+
+  on_request_finished.Run(base::FilePath(), false);
+}
+
+void QuirksManager::RunClient(
+    int64_t product_id,
+    const RequestFinishedCallback& on_request_finished) {
+  QuirksClient* client =
+      new QuirksClient(product_id, on_request_finished, this);
+  clients_.insert(make_scoped_ptr(client));
+  client->StartDownload();
+}
+
+void QuirksManager::SetLastServerCheck(int64_t product_id,
+                                       const base::Time& last_check) {
+  DCHECK(base::ThreadTaskRunnerHandle::IsSet());
+  DictionaryPrefUpdate dict(local_state_, prefs::kQuirksClientLastServerCheck);
+  dict->SetDouble(IdToHexString(product_id), last_check.ToDoubleT());
+}
+
+}  // namespace quirks