Refactor RulesRegistryWithCache to RulesRegistry

chrome/browser/extensions/api/declarative/rules_cache_delegate.h

 // Copyright 2013 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 CHROME_BROWSER_EXTENSIONS_API_IMAGE_WRITER_PRIVATE_OPERATION_MANAGER_H_
-#define CHROME_BROWSER_EXTENSIONS_API_IMAGE_WRITER_PRIVATE_OPERATION_MANAGER_H_
+#ifndef CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_CACHE_DELEGATE_H__
+#define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_CACHE_DELEGATE_H__
 
-#include <map>
+#include <set>
 #include <string>
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/memory/weak_ptr.h"
-#include "base/stl_util.h"
-#include "base/timer/timer.h"
-#include "chrome/browser/extensions/api/image_writer_private/image_writer_private_api.h"
-#include "chrome/browser/extensions/api/image_writer_private/operation.h"
-#include "chrome/browser/extensions/api/profile_keyed_api_factory.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/common/extensions/api/image_writer_private.h"
+
+#include "base/gtest_prod_util.h"
+#include "base/values.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
-#include "url/gurl.h"
 
-namespace image_writer_api = extensions::api::image_writer_private;
+class Profile;
 
 namespace extensions {
-namespace image_writer {
 
-class Operation;
+class RulesRegistry;
 
-// Manages image writer operations for the current profile.  Including clean-up
-// and message routing.
-class OperationManager
-    : public ProfileKeyedAPI,
-      public content::NotificationObserver,
-      public base::SupportsWeakPtr<OperationManager> {
- public:
-  typedef std::string ExtensionId;
+// RulesCacheDelegate implements the part of the RulesRegistry which works on
+// the UI thread. It should only be used on the UI thread. It gets created
+// by the RulesRegistry, but right after that it changes owner to the
+// RulesRegistryService, and is deleted by the service.

[Jeffrey Yasskin, 2013/10/30 22:30:48]

Although note that if the tests use TestBrowserThreadBundle, we could probably
go back to having the RulesCacheDelegate actually owned by its RulesRegistry.

[Fady Samuel, 2013/10/31 14:02:24]

In a subsequent patch, RulesCacheDelegate will be made optional. However
transferring ownership to the RulesRegistry might be nice. I'll look into it.

+// If |log_storage_init_delay| is set, the delay caused by loading and
+// registering rules on initialization will be logged with UMA.
+class RulesCacheDelegate : public content::NotificationObserver {
+  public:
+  // |event_name| identifies the JavaScript event for which rules are
+  // registered. For example, for WebRequestRulesRegistry the name is
+  // "declarativeWebRequest.onRequest".
+  RulesCacheDelegate(Profile* profile,
+                     const std::string& event_name,
+                     content::BrowserThread::ID rules_registry_thread,
+                     base::WeakPtr<RulesRegistry> registry,
+                     bool log_storage_init_delay);
 
-  explicit OperationManager(Profile* profile);
-  virtual ~OperationManager();
+  virtual ~RulesCacheDelegate();
 
-  virtual void Shutdown() OVERRIDE;
+  // Returns a key for the state store. The associated preference is a boolean
+  // indicating whether there are some declarative rules stored in the rule
+  // store.
+  static std::string GetRulesStoredKey(const std::string& event_name,
+                                       bool incognito);
 
-  // Starts a WriteFromUrl operation.
-  void StartWriteFromUrl(const ExtensionId& extension_id,
-                         GURL url,
-                         content::RenderViewHost* rvh,
-                         const std::string& hash,
-                         bool saveImageAsDownload,
-                         const std::string& storage_unit_id,
-                         const Operation::StartWriteCallback& callback);
+  // Initialize the storage functionality.
+  void Init();
 
-  // Starts a WriteFromFile operation.
-  void StartWriteFromFile(const ExtensionId& extension_id,
-                          const std::string& storage_unit_id,
-                          const Operation::StartWriteCallback& callback);
+  void WriteToStorage(const std::string& extension_id,
+                      scoped_ptr<base::Value> value);
 
-  // Cancels the extensions current operation if any.
-  void CancelWrite(const ExtensionId& extension_id,
-                   const Operation::CancelWriteCallback& callback);
+  base::WeakPtr<RulesCacheDelegate> GetWeakPtr() {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+    return weak_ptr_factory_.GetWeakPtr();
+  }
 
-  // Callback for progress events.
-  void OnProgress(const ExtensionId& extension_id,
-                  image_writer_api::Stage stage,
-                  int progress);
-  // Callback for completion events.
-  void OnComplete(const ExtensionId& extension_id);
+  private:
+  FRIEND_TEST_ALL_PREFIXES(RulesRegistryWithCacheTest,
+                           DeclarativeRulesStored);
+  FRIEND_TEST_ALL_PREFIXES(RulesRegistryWithCacheTest,
+                           RulesStoredFlagMultipleRegistries);
 
-  // Callback for error events.
-  // TODO (haven): Add error codes.
-  void OnError(const ExtensionId& extension_id,
-               image_writer_api::Stage stage,
-               int progress,
-               const std::string& error_message);
-
-  // ProfileKeyedAPI
-  static ProfileKeyedAPIFactory<OperationManager>*
-      GetFactoryInstance();
-  static OperationManager* Get(Profile* profile);
-
-  Profile* profile() { return profile_; }
-
- private:
-
-  static const char* service_name() {
-    return "OperationManager";
-  }
+  static const char kRulesStoredKey[];
 
   // NotificationObserver
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
-  Operation* GetOperation(const ExtensionId& extension_id);
-  void DeleteOperation(const ExtensionId& extension_id);
+  // Check if we are done reading all data from storage on startup, and notify
+  // the RulesRegistry on its thread if so. The notification is delivered
+  // exactly once.
+  void CheckIfReady();
 
-  friend class ProfileKeyedAPIFactory<OperationManager>;
-  typedef std::map<ExtensionId, scoped_refptr<Operation> > OperationMap;
+  // Schedules retrieving rules for already loaded extensions where
+  // appropriate.
+  void ReadRulesForInstalledExtensions();
+
+  // Read/write a list of rules serialized to Values.
+  void ReadFromStorage(const std::string& extension_id);
+  void ReadFromStorageCallback(const std::string& extension_id,
+                               scoped_ptr<base::Value> value);
+
+  // Check the preferences whether the extension with |extension_id| has some
+  // rules stored on disk. If this information is not in the preferences, true
+  // is returned as a safe default value.
+  bool GetDeclarativeRulesStored(const std::string& extension_id) const;
+  // Modify the preference to |rules_stored|.
+  void SetDeclarativeRulesStored(const std::string& extension_id,
+                                 bool rules_stored);
+
+  content::NotificationRegistrar registrar_;
 
   Profile* profile_;
-  OperationMap operations_;
-  content::NotificationRegistrar registrar_;
 
-  base::WeakPtrFactory<OperationManager> weak_factory_;
+  // The key under which rules are stored.
+  const std::string storage_key_;
 
-  DISALLOW_COPY_AND_ASSIGN(OperationManager);
+  // The key under which we store whether the rules have been stored.
+  const std::string rules_stored_key_;
+
+  // A set of extension IDs that have rules we are reading from storage.
+  std::set<std::string> waiting_for_extensions_;
+
+  // We measure the time spent on loading rules on init. The result is logged
+  // with UMA once per each RulesCacheDelegate instance, unless in Incognito.
+  base::Time storage_init_time_;
+  bool log_storage_init_delay_;
+
+  // Weak pointer to post tasks to the owning rules registry.
+  const base::WeakPtr<RulesRegistry> registry_;
+
+  // The thread |registry_| lives on.
+  const content::BrowserThread::ID rules_registry_thread_;
+
+  // We notified the RulesRegistry that the rules are loaded.
+  bool notified_registry_;
+
+  // Use this factory to generate weak pointers bound to the UI thread.
+  base::WeakPtrFactory<RulesCacheDelegate> weak_ptr_factory_;
 };
 
-}  // namespace image_writer
 }  // namespace extensions
 
-#endif  // CHROME_BROWSER_EXTENSIONS_API_IMAGE_WRITER_PRIVATE_OPERATION_MANAGER_H_
+#endif  // CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_CACHE_DELEGATE_H__