Start managed_mode refactor.

chrome/browser/managed_mode/managed_user_service.h

 // Copyright (c) 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_MANAGED_MODE_MANAGED_USER_SERVICE_H_
 #define CHROME_BROWSER_MANAGED_MODE_MANAGED_USER_SERVICE_H_
 
 #include <set>
 #include <vector>
 
@@ skipping 40 matching lines @@
   typedef std::vector<base::string16> CategoryList;
   typedef base::Callback<void(content::WebContents*)> NavigationBlockedCallback;
   typedef base::Callback<void(const GoogleServiceAuthError&)> AuthErrorCallback;
 
   enum ManualBehavior {
     MANUAL_NONE = 0,
     MANUAL_ALLOW,
     MANUAL_BLOCK
   };
 
+  class Delegate {
+   public:
+    virtual ~Delegate() {}
+    // Returns true to indicate that the delegate handled the (de)activation, or
+    // false to indicate that the ManagedUserService itself should handle it.
+    virtual bool SetActive(bool active) = 0;
+  };
+
   virtual ~ManagedUserService();
 
   // ProfileKeyedService override:
   virtual void Shutdown() OVERRIDE;
 
   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
 
   static void MigrateUserPrefs(PrefService* prefs);
 
+  void SetDelegate(Delegate* delegate);
+
   // Returns the URL filter for the IO thread, for filtering network requests
   // (in ManagedModeResourceThrottle).
   scoped_refptr<const ManagedModeURLFilter> GetURLFilterForIOThread();
 
   // Returns the URL filter for the UI thread, for filtering navigations and
   // classifying sites in the history view.
   ManagedModeURLFilter* GetURLFilterForUIThread();
 
   // Returns the URL's category, obtained from the installed content packs.
   int GetCategory(const GURL& url);
@@ skipping 113 matching lines @@
     scoped_refptr<ManagedModeURLFilter> ui_url_filter_;
     scoped_refptr<ManagedModeURLFilter> io_url_filter_;
 
     DISALLOW_COPY_AND_ASSIGN(URLFilterContext);
   };
 
   // Use |ManagedUserServiceFactory::GetForProfile(..)| to get
   // an instance of this service.
   explicit ManagedUserService(Profile* profile);
 
+  void SetActive(bool active);
+
   void OnCustodianProfileDownloaded(const base::string16& full_name);
 
   void OnManagedUserRegistered(const AuthErrorCallback& callback,
                                Profile* custodian_profile,
                                const GoogleServiceAuthError& auth_error,
                                const std::string& token);
 
   void SetupSync();
 
   bool ProfileIsManaged() const;
 
   // Internal implementation for ExtensionManagementPolicy::Delegate methods.
   // If |error| is not NULL, it will be filled with an error message if the
   // requested extension action (install, modify status, etc.) is not permitted.
   bool ExtensionManagementPolicyImpl(const extensions::Extension* extension,
                                      base::string16* error) const;
 
   // Returns a list of all installed and enabled site lists in the current
   // managed profile.
   ScopedVector<ManagedModeSiteList> GetActiveSiteLists();
 
   ManagedUserSettingsService* GetSettingsService();
 
+  void OnManagedUserIdChanged();
+
   void OnDefaultFilteringBehaviorChanged();
 
   void UpdateSiteLists();
 
   // Updates the manual overrides for hosts in the URL filters when the
   // corresponding preference is changed.
   void UpdateManualHosts();
 
   // Updates the manual overrides for URLs in the URL filters when the
   // corresponding preference is changed.
   void UpdateManualURLs();
 
   // Owns us via the KeyedService mechanism.
   Profile* profile_;
 
+  bool active_;
+
+  Delegate* delegate_;
+
   ScopedObserver<extensions::ExtensionRegistry,
                  extensions::ExtensionRegistryObserver>
       extension_registry_observer_;
 
   PrefChangeRegistrar pref_change_registrar_;
 
   // True iff we're waiting for the Sync service to be initialized.
   bool waiting_for_sync_initialization_;
   bool is_profile_active_;
 
@@ skipping 10 matching lines @@
   // Used to create permission requests.
   scoped_ptr<PermissionRequestCreator> permissions_creator_;
 
   // True iff we are waiting for a permission request to be issued.
   bool waiting_for_permissions_;
 
   base::WeakPtrFactory<ManagedUserService> weak_ptr_factory_;
 };
 
 #endif  // CHROME_BROWSER_MANAGED_MODE_MANAGED_USER_SERVICE_H_