Supervised Users Initiated Installs v2

chrome/browser/supervised_user/supervised_user_service.h

 // Copyright 2014 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_SUPERVISED_USER_SUPERVISED_USER_SERVICE_H_
 #define CHROME_BROWSER_SUPERVISED_USER_SUPERVISED_USER_SERVICE_H_
 
 #include <stddef.h>
 
 #include <map>
@@ skipping 12 matching lines @@
 #include "chrome/browser/net/file_downloader.h"
 #include "chrome/browser/supervised_user/experimental/safe_search_url_reporter.h"
 #include "chrome/browser/supervised_user/experimental/supervised_user_blacklist.h"
 #include "chrome/browser/supervised_user/supervised_user_url_filter.h"
 #include "chrome/browser/supervised_user/supervised_users.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/sync_driver/sync_service_observer.h"
 #include "components/sync_driver/sync_type_preference_provider.h"
+#include "extensions/browser/extension_registry_observer.h"
 #include "net/url_request/url_request_context_getter.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "extensions/browser/management_policy.h"
 #endif
 
 class Browser;
 class GoogleServiceAuthError;
 class PermissionRequestCreator;
 class Profile;
@@ skipping 26 matching lines @@
 // manual whitelist/blacklist overrides).
 class SupervisedUserService : public KeyedService,
 #if defined(ENABLE_EXTENSIONS)
                               public extensions::ManagementPolicy::Provider,
 #endif
                               public SyncTypePreferenceProvider,
 #if !defined(OS_ANDROID)
                               public sync_driver::SyncServiceObserver,
                               public chrome::BrowserListObserver,
 #endif
-                              public SupervisedUserURLFilter::Observer {
+                              public SupervisedUserURLFilter::Observer,
+                              public extensions::ExtensionRegistryObserver {

[Marc Treib, 2016/06/03 13:24:14]

This should go into the ENABLE_EXTENSIONS above

[mamir, 2016/06/06 15:01:37]

Done.

  public:
   using NavigationBlockedCallback = base::Callback<void(content::WebContents*)>;
   using AuthErrorCallback = base::Callback<void(const GoogleServiceAuthError&)>;
   using SuccessCallback = base::Callback<void(bool)>;
 
   class Delegate {
    public:
     virtual ~Delegate() {}
     // Returns true to indicate that the delegate handled the (de)activation, or
     // false to indicate that the SupervisedUserService itself should handle it.
@@ skipping 28 matching lines @@
   // extensions.
   bool AccessRequestsEnabled();
 
   // Adds an access request for the given URL.
   void AddURLAccessRequest(const GURL& url, const SuccessCallback& callback);
 
   // Reports |url| to the SafeSearch API, because the user thinks this is an
   // inappropriate URL.
   void ReportURL(const GURL& url, const SuccessCallback& callback);
 
+  // Adds an install request for the given WebStore item (App/Extension).
+  void AddExtensionInstallRequest(const std::string& extension_id,
+                                  const base::Version& version,
+                                  const SuccessCallback& callback);
+
+  // Same as above, but without a callback, just logging errors on failure.
+  void AddExtensionInstallRequest(const std::string& extension_id,
+                                  const base::Version& version);
+
   // Adds an update request for the given WebStore item (App/Extension).
   void AddExtensionUpdateRequest(const std::string& extension_id,
                                  const base::Version& version,
                                  const SuccessCallback& callback);
 
   // Same as above, but without a callback, just logging errors on failure.
   void AddExtensionUpdateRequest(const std::string& extension_id,
                                  const base::Version& version);
 
-  // Get the string used to identify an extension update request. Public for
-  // testing.
-  static std::string GetExtensionUpdateRequestId(
-      const std::string& extension_id,
-      const base::Version& version);
+  // Get the string used to identify an extension install or update request.
+  // Public for testing.
+  static std::string GetExtensionRequestId(const std::string& extension_id,
+                                           const base::Version& version);
+
+  // Updates the approved version of the extensions in the
+  // approved_extensions_map_.
+  void UpdateApprovedVersion(const std::string& extension_id,

[Marc Treib, 2016/06/03 13:24:14]

UpdateApprovedExtensionVersion?

[mamir, 2016/06/06 15:01:37]

Done.

+                             const base::Version& version);
 
   // Returns the email address of the custodian.
   std::string GetCustodianEmailAddress() const;
 
   // Returns the name of the custodian, or the email address if the name is
   // empty.
   std::string GetCustodianName() const;
 
   // Returns the email address of the second custodian, or the empty string
   // if there is no second custodian.
@@ skipping 55 matching lines @@
 #endif  // !defined(OS_ANDROID)
 
   // SupervisedUserURLFilter::Observer implementation:
   void OnSiteListUpdated() override;
 
  private:
   friend class SupervisedUserServiceExtensionTestBase;
   friend class SupervisedUserServiceFactory;
   FRIEND_TEST_ALL_PREFIXES(SingleClientSupervisedUserSettingsSyncTest, Sanity);
   FRIEND_TEST_ALL_PREFIXES(SupervisedUserServiceTest, ClearOmitOnRegistration);
-  FRIEND_TEST_ALL_PREFIXES(SupervisedUserServiceExtensionTest,
-                           ExtensionManagementPolicyProvider);
+  FRIEND_TEST_ALL_PREFIXES(
+      SupervisedUserServiceExtensionTest,
+      ExtensionManagementPolicyProviderWithoutSUInitiatedInstalls);
+  FRIEND_TEST_ALL_PREFIXES(
+      SupervisedUserServiceExtensionTest,
+      ExtensionManagementPolicyProviderWithSUInitiatedInstalls);
 
   using CreatePermissionRequestCallback =
       base::Callback<void(PermissionRequestCreator*, const SuccessCallback&)>;
 
   // A bridge from the UI thread to the SupervisedUserURLFilters, one of which
   // lives on the IO thread. This class mediates access to them and makes sure
   // they are kept in sync.
   class URLFilterContext {
    public:
     URLFilterContext();
@@ skipping 61 matching lines @@
 
 #if defined(ENABLE_EXTENSIONS)
   // extensions::ManagementPolicy::Provider implementation:
   std::string GetDebugPolicyProviderName() const override;
   bool UserMayLoad(const extensions::Extension* extension,
                    base::string16* error) const override;
   bool UserMayModifySettings(const extensions::Extension* extension,
                              base::string16* error) const override;
   bool MustRemainInstalled(const extensions::Extension* extension,
                            base::string16* error) const override;
+  bool MustRemainDisabled(const extensions::Extension* extension,
+                          extensions::Extension::DisableReason* reason,
+                          base::string16* error) const override;
+
+  // An extension can be in one of the following states:
+  //
+  // FORCED: if it is installed by the custodian.
+  // REQUIRE_APPROVAL: if it is installed by the supervised user and
+  //    hasn't been approved by the custodian yet.
+  // ALLOWED: Components, Themes, Default extensions ..etc
+  //    are generally allowed.  Extensions that have been approved by the
+  //    custodian are also allowed.
+  // BLOCKED: if it is not ALLOWED or FORCED
+  //    and supervised users initiated installs are disabled.
+  enum class ExtensionState { FORCED, BLOCKED, ALLOWED, REQUIRE_APPROVAL };
+
+  ExtensionState GetExtensionState(
+      const extensions::Extension& extension) const;
 
   // Extensions helper to SetActive().
   void SetExtensionsActive();
 #endif
 
   SupervisedUserSettingsService* GetSettingsService();
 
   size_t FindEnabledPermissionRequestCreator(size_t start);
   void AddPermissionRequestInternal(
       const CreatePermissionRequestCallback& create_request,
@@ skipping 35 matching lines @@
   void UpdateBlacklist();
 
   // 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();
 
+  // Updates the map of approved extensions when the corresponding preference
+  // is changed.
+  void UpdateApprovedExtensions();
+
+  // Checks the disable reasons and enables the extension if possible.
+  void EnableExtensionIfPossible(const std::string& extension_id);
+
   // Returns the human readable name of the supervised user.
   std::string GetSupervisedUserName() const;
 
   // Subscribes to the SupervisedUserPrefStore, refreshes
   // |includes_sync_sessions_type_| and triggers reconfiguring the
   // ProfileSyncService.
   void OnForceSessionSyncChanged();
 
+  // extensions::ExtensionRegistryObserver overrides:
+  void OnExtensionInstalled(content::BrowserContext* browser_context,

[Marc Treib, 2016/06/03 13:24:14]

This should go into the ENABLE_EXTENSIONS above; EnableExtensionIfPossible
probably too.

[mamir, 2016/06/06 15:01:37]

Done.

+                            const extensions::Extension* extension,
+                            bool is_update) override;
+
   // The option a custodian sets to either record or prevent recording the
   // supervised user's history. Set by |FetchNewSessionSyncState()| and
   // defaults to true.
   bool includes_sync_sessions_type_;
 
   // Owns us via the KeyedService mechanism.
   Profile* profile_;
 
   bool active_;
 
   Delegate* delegate_;
 
   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_;
 
   std::vector<NavigationBlockedCallback> navigation_blocked_callbacks_;
 
   // True only when |Init()| method has been called.
   bool did_init_;
 
   // True only when |Shutdown()| method has been called.
   bool did_shutdown_;
 
   URLFilterContext url_filter_context_;
 
+  // Stores a map from extension_id -> approved version by the custodian.
+  // It is only relevant for SU-initiated installs.
+  std::map<std::string, base::Version> approved_extensions_map_;
+
   enum class BlacklistLoadState {
     NOT_LOADED,
     LOAD_STARTED,
     LOADED
   } blacklist_state_;
 
   SupervisedUserBlacklist blacklist_;
   std::unique_ptr<FileDownloader> blacklist_downloader_;
 
   std::unique_ptr<SupervisedUserWhitelistService> whitelist_service_;
 
   std::vector<scoped_refptr<SupervisedUserSiteList>> whitelists_;
 
   // Used to create permission requests.
   ScopedVector<PermissionRequestCreator> permissions_creators_;
 
   // Used to report inappropriate URLs to SafeSarch API.
   std::unique_ptr<SafeSearchURLReporter> url_reporter_;
 
   base::ObserverList<SupervisedUserServiceObserver> observer_list_;
 
   base::WeakPtrFactory<SupervisedUserService> weak_ptr_factory_;
 };
 
 #endif  // CHROME_BROWSER_SUPERVISED_USER_SUPERVISED_USER_SERVICE_H_