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

chrome/browser/supervised_user/child_accounts/permission_request_creator_apiary.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/child_accounts/permission_request_creator_apiary.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 15 matching lines @@
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 using net::URLFetcher;
 
 const char kApiUrl[] =
     "https://www.googleapis.com/kidsmanagement/v1/people/me/permissionRequests";
 const char kApiScope[] = "https://www.googleapis.com/auth/kid.permission";
 
 const int kNumRetries = 1;
-const char kNamespace[] = "PERMISSION_CHROME_URL";
+
+const char kAuthorizationHeaderFormat[] = "Authorization: Bearer %s";
+
+// Request keys.
+const char kNamespaceKey[] = "namespace";
+const char kObjectRefKey[] = "objectRef";
+const char kStateKey[] = "state";
+
+// Request values.
+const char kNamespaceURLRequest[] = "PERMISSION_CHROME_URL";
+const char kNamespaceUpdateRequest[] = "PERMISSION_CHROME_CWS_ITEM_UPDATE";
 const char kState[] = "PENDING";
 
+// Response keys.
 const char kPermissionRequestKey[] = "permissionRequest";
 const char kIdKey[] = "id";
 
-static const char kAuthorizationHeaderFormat[] = "Authorization: Bearer %s";
-
 struct PermissionRequestCreatorApiary::Request {
-  Request(const GURL& url_requested,
+  Request(const std::string& request_namespace,
+          const std::string& object_ref,
           const SuccessCallback& callback,
           int url_fetcher_id);
   ~Request();
 
-  GURL url_requested;
+  std::string request_namespace;
+  std::string object_ref;
   SuccessCallback callback;
   scoped_ptr<OAuth2TokenService::Request> access_token_request;
   std::string access_token;
   bool access_token_expired;
   int url_fetcher_id;
-  scoped_ptr<net::URLFetcher> url_fetcher;
+  scoped_ptr<URLFetcher> url_fetcher;
 };
 
 PermissionRequestCreatorApiary::Request::Request(
-    const GURL& url_requested,
+    const std::string& request_namespace,
+    const std::string& object_ref,
     const SuccessCallback& callback,
     int url_fetcher_id)
-    : url_requested(url_requested),
+    : request_namespace(request_namespace),
+      object_ref(object_ref),
       callback(callback),
       access_token_expired(false),
       url_fetcher_id(url_fetcher_id) {
 }
 
 PermissionRequestCreatorApiary::Request::~Request() {}
 
 PermissionRequestCreatorApiary::PermissionRequestCreatorApiary(
     OAuth2TokenService* oauth2_token_service,
     const std::string& account_id,
@@ skipping 16 matching lines @@
   return make_scoped_ptr(new PermissionRequestCreatorApiary(
       token_service,
       signin->GetAuthenticatedAccountId(),
       profile->GetRequestContext()));
 }
 
 bool PermissionRequestCreatorApiary::IsEnabled() const {
   return true;
 }
 
-void PermissionRequestCreatorApiary::CreatePermissionRequest(
+void PermissionRequestCreatorApiary::CreateURLAccessRequest(
     const GURL& url_requested,
     const SuccessCallback& callback) {
-  requests_.push_back(new Request(url_requested, callback, url_fetcher_id_));
-  StartFetching(requests_.back());
+  CreateRequest(kNamespaceURLRequest, url_requested.spec(), callback);
+}
+
+void PermissionRequestCreatorApiary::CreateExtensionUpdateRequest(
+    const std::string& extension_id,
+    const SuccessCallback& callback) {
+  CreateRequest(kNamespaceUpdateRequest, extension_id, callback);
 }
 
 GURL PermissionRequestCreatorApiary::GetApiUrl() const {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kPermissionRequestApiUrl)) {
     GURL url(base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
         switches::kPermissionRequestApiUrl));
     LOG_IF(WARNING, !url.is_valid())
         << "Got invalid URL for " << switches::kPermissionRequestApiUrl;
     return url;
   } else {
     return GURL(kApiUrl);
   }
 }
 
 std::string PermissionRequestCreatorApiary::GetApiScope() const {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kPermissionRequestApiScope)) {
     return base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
         switches::kPermissionRequestApiScope);
   } else {
     return kApiScope;
   }
 }
 
+void PermissionRequestCreatorApiary::CreateRequest(
+    const std::string& request_namespace,
+    const std::string& object_ref,
+    const SuccessCallback& callback) {
+  requests_.push_back(
+      new Request(request_namespace, object_ref, callback, url_fetcher_id_));
+  StartFetching(requests_.back());
+}
+
 void PermissionRequestCreatorApiary::StartFetching(Request* request) {
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(GetApiScope());
   request->access_token_request = oauth2_token_service_->StartRequest(
       account_id_, scopes, this);
 }
 
 void PermissionRequestCreatorApiary::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
@@ skipping 13 matching lines @@
                                               this));
 
   (*it)->url_fetcher->SetRequestContext(context_);
   (*it)->url_fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                                    net::LOAD_DO_NOT_SAVE_COOKIES);
   (*it)->url_fetcher->SetAutomaticallyRetryOnNetworkChanges(kNumRetries);
   (*it)->url_fetcher->AddExtraRequestHeader(
       base::StringPrintf(kAuthorizationHeaderFormat, access_token.c_str()));
 
   base::DictionaryValue dict;
-  dict.SetStringWithoutPathExpansion("namespace", kNamespace);
-  dict.SetStringWithoutPathExpansion("objectRef", (*it)->url_requested.spec());
-  dict.SetStringWithoutPathExpansion("state", kState);
+  dict.SetStringWithoutPathExpansion(kNamespaceKey, (*it)->request_namespace);
+  dict.SetStringWithoutPathExpansion(kObjectRefKey, (*it)->object_ref);
+  dict.SetStringWithoutPathExpansion(kStateKey, kState);
+
   std::string body;
   base::JSONWriter::Write(&dict, &body);
   (*it)->url_fetcher->SetUploadData("application/json", body);
 
   (*it)->url_fetcher->Start();
 }
 
 void PermissionRequestCreatorApiary::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
@@ skipping 72 matching lines @@
       it, GoogleServiceAuthError::FromConnectionError(error_code));
 }
 
 void PermissionRequestCreatorApiary::DispatchGoogleServiceAuthError(
     RequestIterator it,
     const GoogleServiceAuthError& error) {
   VLOG(1) << "GoogleServiceAuthError: " << error.ToString();
   (*it)->callback.Run(false);
   requests_.erase(it);
 }