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..7ee39d43c3b8e637227b45720c9fb9a2d000e133
--- /dev/null
+++ b/components/quirks/quirks_manager.cc
@@ -0,0 +1,245 @@
+// 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/thread_task_runner_handle.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) {
+  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;
+}
+
+}  // 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);
+}
+
+// Must be called on file thread.
+base::FilePath RequestIccProfilePath(
+    int64_t product_id,
+    const DownloadFinishedCallback& on_download_finished) {
+  if (g_manager)
+    return g_manager->RequestIccFilePath(product_id, on_download_finished);
+
+  VLOG(1) << "Quirks Client Manager not initialized; can't get icc file.";
+  return base::FilePath();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 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),
+      client_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      is_new_device_(false),
+      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,
+                                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);
+}
+
+base::FilePath QuirksManager::RequestIccFilePath(
+    int64_t product_id,
+    const DownloadFinishedCallback& on_download_finished) {
+  DCHECK(blocking_pool()->RunsTasksOnCurrentThread());
+
+  // 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.
+  base::FilePath path = delegate_->GetBuiltInDisplayProfileDirectory().Append(
+      IdToFileName(product_id));
+  if (CheckAndLogFile(path))
+    return 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.
+  path = delegate_->GetDownloadDisplayProfileDirectory().Append(
+      IdToFileName(product_id));
+  if (CheckAndLogFile(path))
+    return path;
+
+  // TODO(glevin): Eventually we'll want to check the server for updates to
+  // files, so we'll still want to get down here even if we find the icc file.
+
+  // Record this on file thread for future use on client task runner.
+  is_new_device_ = (delegate_->GetDaysSinceOobe() <= kDaysBetweenServerChecks);
+
+  client_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&QuirksManager::RunClientOnTaskRunner,
+                            weak_ptr_factory_.GetWeakPtr(), product_id,
+                            on_download_finished));
+
+  return base::FilePath();
+}
+
+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;
+                         });
+  DCHECK(it != clients_.end());
+  if (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);
+}
+
+bool QuirksManager::NeedToCheckServer(int64_t product_id) {
+  DCHECK(base::ThreadTaskRunnerHandle::IsSet());
+  double last_check = 0.0;
+  local_state_->GetDictionary(prefs::kQuirksClientLastServerCheck)
+      ->GetDouble(IdToHexString(product_id), &last_check);
+
+  if (last_check != 0.0) {
+    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);
+      return false;
+    }
+
+    return true;
+  }
+
+  // On new devices, we want to check server immediately.
+  if (is_new_device_)
+    return true;
+
+  // 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.";
+  return false;
+}
+
+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());
+}
+
+// Initializes QuirksClient object on client task runner, where most of its work
+// needs to be done.
+void QuirksManager::RunClientOnTaskRunner(
+    int64_t product_id,
+    const DownloadFinishedCallback& on_download_finished) {
+  DCHECK(base::ThreadTaskRunnerHandle::IsSet());
+  if (!ValidateOnTaskRunner()) {
+    VLOG(1) << "Quirks Manager not correctly initialized.";
+    return;
+  }
+
+  if (!NeedToCheckServer(product_id))
+    return;
+
+  QuirksClient* client =
+      new QuirksClient(product_id, on_download_finished, this);
+  clients_.insert(make_scoped_ptr(client));
+  client->StartDownload();
+}
+
+bool QuirksManager::ValidateOnTaskRunner() {
+  return base::ThreadTaskRunnerHandle::IsSet() &&
+         local_state_->CalledOnValidThread() &&
+         client_task_runner_->RunsTasksOnCurrentThread();
+}
+
+}  // namespace quirks