Supervised users: When an extension requires new permissions, send request to custodian

chrome/browser/supervised_user/supervised_user_service.cc

 // 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.
 
 #include "chrome/browser/supervised_user/supervised_user_service.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/prefs/pref_service.h"
@@ skipping 60 matching lines @@
   prefs::kSupervisedUserCustodianName,
   prefs::kSupervisedUserCustodianEmail,
   prefs::kSupervisedUserCustodianProfileImageURL,
   prefs::kSupervisedUserCustodianProfileURL,
   prefs::kSupervisedUserSecondCustodianName,
   prefs::kSupervisedUserSecondCustodianEmail,
   prefs::kSupervisedUserSecondCustodianProfileImageURL,
   prefs::kSupervisedUserSecondCustodianProfileURL,
 };
 
+void CreateURLAccessRequest(
+    const GURL& url,
+    PermissionRequestCreator* creator,
+    const SupervisedUserService::SuccessCallback& callback) {
+  creator->CreateURLAccessRequest(url, callback);
+}
+
+void CreateExtensionUpdateRequest(
+    const std::string& extension_id,
+    PermissionRequestCreator* creator,
+    const SupervisedUserService::SuccessCallback& callback) {
+  creator->CreateExtensionUpdateRequest(extension_id, callback);
+}
+
 #if defined(ENABLE_EXTENSIONS)
 enum ExtensionState {
   EXTENSION_FORCED,
   EXTENSION_BLOCKED,
   EXTENSION_ALLOWED
 };
 
 ExtensionState GetExtensionState(const extensions::Extension* extension) {
   if (extension->is_theme())
     return EXTENSION_ALLOWED;
@@ skipping 433 matching lines @@
 
 size_t SupervisedUserService::FindEnabledPermissionRequestCreator(
     size_t start) {
   for (size_t i = start; i < permissions_creators_.size(); ++i) {
     if (permissions_creators_[i]->IsEnabled())
       return i;
   }
   return permissions_creators_.size();
 }
 
-void SupervisedUserService::AddAccessRequestInternal(
-    const GURL& url,
+void SupervisedUserService::AddPermissionRequestInternal(
+    const CreatePermissionRequestCallback& create_request,
     const SuccessCallback& callback,
     size_t index) {
   // Find a permission request creator that is enabled.
   size_t next_index = FindEnabledPermissionRequestCreator(index);
   if (next_index >= permissions_creators_.size()) {
     callback.Run(false);
     return;
   }
 
-  permissions_creators_[next_index]->CreatePermissionRequest(
-      url,
+  create_request.Run(
+      permissions_creators_[next_index],
       base::Bind(&SupervisedUserService::OnPermissionRequestIssued,
-                 weak_ptr_factory_.GetWeakPtr(), url, callback, next_index));
+                 weak_ptr_factory_.GetWeakPtr(), create_request,
+                 callback, next_index));
 }
 
 void SupervisedUserService::OnPermissionRequestIssued(
-    const GURL& url,
+    const CreatePermissionRequestCallback& create_request,
     const SuccessCallback& callback,
     size_t index,
     bool success) {
   if (success) {
     callback.Run(true);
     return;
   }
 
-  AddAccessRequestInternal(url, callback, index + 1);
+  AddPermissionRequestInternal(create_request, callback, index + 1);
 }
 
 void SupervisedUserService::OnSupervisedUserIdChanged() {
   SetActive(ProfileIsSupervised());
 }
 
 void SupervisedUserService::OnDefaultFilteringBehaviorChanged() {
   DCHECK(ProfileIsSupervised());
 
   int behavior_value = profile_->GetPrefs()->GetInteger(
@@ skipping 52 matching lines @@
 
 void SupervisedUserService::OnBlacklistLoaded() {
   FOR_EACH_OBSERVER(
       SupervisedUserServiceObserver, observer_list_, OnURLFilterChanged());
 }
 
 bool SupervisedUserService::AccessRequestsEnabled() {
   return FindEnabledPermissionRequestCreator(0) < permissions_creators_.size();
 }
 
-void SupervisedUserService::AddAccessRequest(const GURL& url,
-                                             const SuccessCallback& callback) {
-  AddAccessRequestInternal(SupervisedUserURLFilter::Normalize(url), callback,
-                           0);
+void SupervisedUserService::AddURLAccessRequest(
+    const GURL& url,
+    const SuccessCallback& callback) {
+  AddPermissionRequestInternal(
+      base::Bind(CreateURLAccessRequest,
+                 SupervisedUserURLFilter::Normalize(url)),
+      callback, 0);
+}
+
+void SupervisedUserService::AddExtensionUpdateRequest(
+    const std::string& extension_id,
+    const SuccessCallback& callback) {
+  AddPermissionRequestInternal(
+      base::Bind(CreateExtensionUpdateRequest, extension_id),
+      callback, 0);
 }
 
 void SupervisedUserService::InitSync(const std::string& refresh_token) {
   StartSetupSync();
 
   ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
   token_service->UpdateCredentials(supervised_users::kSupervisedUserPseudoEmail,
                                    refresh_token);
 
@@ skipping 265 matching lines @@
   // The active user can be NULL in unit tests.
   if (user_manager::UserManager::Get()->GetActiveUser()) {
     return UTF16ToUTF8(user_manager::UserManager::Get()->GetUserDisplayName(
         user_manager::UserManager::Get()->GetActiveUser()->GetUserID()));
   }
   return std::string();
 #else
   return profile_->GetPrefs()->GetString(prefs::kProfileName);
 #endif
 }