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

chrome/browser/supervised_user/supervised_user_service.cc

Index: chrome/browser/supervised_user/supervised_user_service.cc
diff --git a/chrome/browser/supervised_user/supervised_user_service.cc b/chrome/browser/supervised_user/supervised_user_service.cc
index e464400c0cc5618681451f5eba6191d746681cc7..b5ae8e40eb07ca7ba3a43cf7544150c6428d776f 100644
--- a/chrome/browser/supervised_user/supervised_user_service.cc
+++ b/chrome/browser/supervised_user/supervised_user_service.cc
@@ -531,7 +531,7 @@ size_t SupervisedUserService::FindEnabledPermissionRequestCreator(
   return permissions_creators_.size();
 }
 
-void SupervisedUserService::AddAccessRequestInternal(
+void SupervisedUserService::AddURLAccessRequestInternal(
     const GURL& url,
     const SuccessCallback& callback,
     size_t index) {
@@ -542,13 +542,13 @@ void SupervisedUserService::AddAccessRequestInternal(
     return;
   }
 
-  permissions_creators_[next_index]->CreatePermissionRequest(
+  permissions_creators_[next_index]->CreateURLAccessRequest(
       url,
-      base::Bind(&SupervisedUserService::OnPermissionRequestIssued,
+      base::Bind(&SupervisedUserService::OnURLAccessRequestIssued,
                  weak_ptr_factory_.GetWeakPtr(), url, callback, next_index));
 }
 
-void SupervisedUserService::OnPermissionRequestIssued(
+void SupervisedUserService::OnURLAccessRequestIssued(
     const GURL& url,
     const SuccessCallback& callback,
     size_t index,
@@ -558,7 +558,38 @@ void SupervisedUserService::OnPermissionRequestIssued(
     return;
   }
 
-  AddAccessRequestInternal(url, callback, index + 1);
+  AddURLAccessRequestInternal(url, callback, index + 1);
+}
+
+void SupervisedUserService::AddExtensionUpdateRequestInternal(
+    const std::string& extension_id,
+    const SuccessCallback& callback,
+    size_t index) {
+  // Find a permission request creator that is enabled.

[Bernhard Bauer, 2015/03/02 16:41:56]

Urr... it's not particularly nice to duplicate this code.

An alternative would be to have a single SendRequest method that can take
different kinds of requests. A request could either have polymorphism via
subclasses (more OO-like), or be a flat struct (less overhead).

[Marc Treib, 2015/03/02 18:26:00]

Done.

+  size_t next_index = FindEnabledPermissionRequestCreator(index);
+  if (next_index >= permissions_creators_.size()) {
+    callback.Run(false);
+    return;
+  }
+
+  permissions_creators_[next_index]->CreateExtensionUpdateRequest(
+      extension_id,
+      base::Bind(&SupervisedUserService::OnExtensionUpdateRequestIssued,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 extension_id, callback, next_index));
+}
+
+void SupervisedUserService::OnExtensionUpdateRequestIssued(
+    const std::string& extension_id,
+    const SuccessCallback& callback,
+    size_t index,
+    bool success) {
+  if (success) {
+    callback.Run(true);
+    return;
+  }
+
+  AddExtensionUpdateRequestInternal(extension_id, callback, index + 1);
 }
 
 void SupervisedUserService::OnSupervisedUserIdChanged() {
@@ -631,10 +662,17 @@ 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) {
+  AddURLAccessRequestInternal(
+      SupervisedUserURLFilter::Normalize(url), callback, 0);
+}
+
+void SupervisedUserService::AddExtensionUpdateRequest(
+    const std::string& extension_id,
+    const SuccessCallback& callback) {
+  AddExtensionUpdateRequestInternal(extension_id, callback, 0);
 }
 
 void SupervisedUserService::InitSync(const std::string& refresh_token) {