Quirks Client for downloading and providing display profiles

components/quirks/quirks_manager.h

+// 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.
+
+#ifndef COMPONENTS_QUIRKS_QUIRKS_MANAGER_H_
+#define COMPONENTS_QUIRKS_QUIRKS_MANAGER_H_
+
+#include <set>
+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/time/time.h"
+#include "components/quirks/quirks_client.h"
+#include "components/quirks/quirks_export.h"
+
+class GURL;
+class PrefRegistrySimple;
+class PrefService;
+
+namespace base {
+class SequencedWorkerPool;
+class SingleThreadTaskRunner;
+}
+
+namespace net {
+class URLFetcher;
+class URLFetcherDelegate;
+class URLRequestContextGetter;
+}
+
+namespace quirks {
+
+// Format int as hex string for filename.
+QUIRKS_EXPORT std::string IdToHexString(int64_t product_id);
+
+// Append ".icc" to hex string in filename.
+QUIRKS_EXPORT std::string IdToFileName(int64_t product_id);
+
+// Finds icc file, if it exists; creates and starts QuirksClient if it doesn't.
+// In all cases, sends results to provided callback.
+QUIRKS_EXPORT void RequestIccProfilePath(
+    int64_t product_id,
+    const RequestFinishedCallback& on_request_finished);
+
+// Handles needed components from browser (local preferences, url context
+// getter, blocking pool, etc).
+class QUIRKS_EXPORT QuirksManager {
+ public:
+  using FakeQuirksFetcherCreator =
+      base::Callback<scoped_ptr<net::URLFetcher>(const GURL&,
+                                                 net::URLFetcherDelegate*)>;
+
+  // Delegate class, so implementation can access browser functionality.
+  class Delegate : public base::RefCounted<Delegate> {

[stevenjb, 2016/02/29 20:22:29]

Why do we need to refcount the delegate? That's very unusual, please explain in
the comment if necessary.

[Greg Levin, 2016/03/02 00:00:26]

CheckForIccFileAndNewDevice() needs the delegate to access code in
chrome/browser/etc.  But I didn't want the QM, and thus the delegate, to be
destroyed before/during CheckForIccFileAndNewDevice().  My intention was to have
the delegate arg hold a reference for as long as CheckForIccFileAndNewDevice()
needed it, since the delegate doesn't actually depend on QM still being alive. 
In short, I felt QM should share ownership of the delegate with this function.

Does that make any sense?  Is there a better way to do this?

[Greg Levin, 2016/03/07 16:34:38]

UPDATE: Delegate no longer passed to CheckForIccFile(), so RefCounted has been
removed.

+   public:

[stevenjb, 2016/02/29 20:22:29]

Delegate methods should be commented here.

[Greg Levin, 2016/03/02 00:00:26]

Done.

+    virtual std::string GetApiKey() const = 0;
+    virtual base::FilePath GetBuiltInDisplayProfileDirectory() const = 0;
+    virtual base::FilePath GetDownloadDisplayProfileDirectory() const = 0;
+    virtual void CheckDaysSinceOobe() = 0;     // Must run on file thread.
+    virtual int GetDaysSinceOobe() const = 0;  // Must call after CheckDays.
+
+   protected:
+    friend class base::RefCounted<Delegate>;
+    virtual ~Delegate() = default;
+
+    DISALLOW_ASSIGN(Delegate);
+  };
+
+  static void Initialize(
+      scoped_refptr<Delegate> delegate,
+      scoped_refptr<base::SequencedWorkerPool> blocking_pool,
+      PrefService* local_state,
+      scoped_refptr<net::URLRequestContextGetter> url_context_getter);
+  static void Shutdown();
+  static QuirksManager* Get();
+
+  static void RegisterPrefs(PrefRegistrySimple* registry);
+
+  // Entry point into manager.  Finds or downloads icc file.
+  void RequestIccFilePath(int64_t product_id,
+                          const RequestFinishedCallback& on_request_finished);
+
+  void ClientFinished(QuirksClient* client);
+
+  // UMA stats for server check reason and results.
+  void RecordReasonUmaStat(QuirksClient::RequestReason reason);
+  void RecordFileFoundUmaStat(bool success);
+
+  // Creates a real URLFetcher for OS, and a fake one for tests.
+  scoped_ptr<net::URLFetcher> CreateURLFetcher(
+      const std::string& url,
+      net::URLFetcherDelegate* delegate);
+
+  Delegate* delegate() const { return delegate_.get(); }
+  base::SequencedWorkerPool* blocking_pool() const {
+    return blocking_pool_.get();
+  }
+
+  net::URLRequestContextGetter* url_context_getter() const {
+    return url_context_getter_.get();
+  }
+
+ protected:
+  friend class QuirksBrowserTest;
+
+  void SetFakeQuirksFetcherCreatorForTests(
+      const FakeQuirksFetcherCreator& creator) {
+    fake_quirks_fetcher_creator_ = creator;
+  }
+
+ private:
+  QuirksManager(scoped_refptr<Delegate> delegate,
+                scoped_refptr<base::SequencedWorkerPool> blocking_pool,
+                PrefService* local_state,
+                scoped_refptr<net::URLRequestContextGetter> url_context_getter);
+  ~QuirksManager();
+
+  // Callback after checking for existing icc file; launch client if not found.
+  void OnIccFilePathRequestCompleted(
+      int64_t product_id,
+      const RequestFinishedCallback& on_request_finished,
+      base::FilePath path);
+
+  // Determines need to check based on previous check time and device age.
+  bool NeedToCheckServer(int64_t product_id);
+
+  // Records time of most recent server check.
+  void SetLastServerCheck(int64_t product_id, const base::Time& last_check);
+
+  std::set<scoped_ptr<QuirksClient>> clients_;
+
+  // These objects provide resources from the browser.
+  scoped_refptr<Delegate> delegate_;  // Impl runs from chrome/browser.
+  scoped_refptr<base::SequencedWorkerPool> blocking_pool_;
+  PrefService* local_state_;  // For local prefs.
+  scoped_refptr<net::URLRequestContextGetter> url_context_getter_;
+
+  FakeQuirksFetcherCreator fake_quirks_fetcher_creator_;  // For tests.
+
+  // Factory for callbacks.
+  base::WeakPtrFactory<QuirksManager> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(QuirksManager);
+};
+
+}  // namespace quirks
+
+#endif  // COMPONENTS_QUIRKS_QUIRKS_MANAGER_H_