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

chrome/browser/supervised_user/supervised_user_service_unittest.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 "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 172 matching lines @@
     profile_ = builder.Build();
     supervised_user_service_ =
         SupervisedUserServiceFactory::GetForProfile(profile_.get());
   }
 
   void TearDown() override { profile_.reset(); }
 
   ~SupervisedUserServiceTest() override {}
 
  protected:
-  void AddAccessRequest(const GURL& url, AsyncResultHolder* result_holder) {
-    supervised_user_service_->AddAccessRequest(
+  void AddURLAccessRequest(const GURL& url, AsyncResultHolder* result_holder) {
+    supervised_user_service_->AddURLAccessRequest(
         url, base::Bind(&AsyncResultHolder::SetResult,
                         base::Unretained(result_holder)));
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<TestingProfile> profile_;
   SupervisedUserService* supervised_user_service_;
 };
 
 }  // namespace
@@ skipping 37 matching lines @@
     ASSERT_LT(index, requested_urls_.size());
     callbacks_[index].Run(result);
     callbacks_.erase(callbacks_.begin() + index);
     requested_urls_.erase(requested_urls_.begin() + index);
   }
 
  private:
   // PermissionRequestCreator:
   bool IsEnabled() const override { return enabled_; }
 
-  void CreatePermissionRequest(const GURL& url_requested,
-                               const SuccessCallback& callback) override {
+  void CreateURLAccessRequest(const GURL& url_requested,
+                              const SuccessCallback& callback) override {
     ASSERT_TRUE(enabled_);
     requested_urls_.push_back(url_requested);
     callbacks_.push_back(callback);
   }
 
+  void CreateExtensionUpdateRequest(const std::string& extension_id,
+                                    const SuccessCallback& callback) override {
+    FAIL();
+  }
+
   bool enabled_;
   std::vector<GURL> requested_urls_;
   std::vector<SuccessCallback> callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(MockPermissionRequestCreator);
 };
 
 }  // namespace
 
 TEST_F(SupervisedUserServiceTest, CreatePermissionRequest) {
   GURL url("http://www.example.com");
 
   // Without any permission request creators, it should be disabled, and any
-  // AddAccessRequest() calls should fail.
+  // AddURLAccessRequest() calls should fail.
   EXPECT_FALSE(supervised_user_service_->AccessRequestsEnabled());
   {
     AsyncResultHolder result_holder;
-    AddAccessRequest(url, &result_holder);
+    AddURLAccessRequest(url, &result_holder);
     EXPECT_FALSE(result_holder.GetResult());
   }
 
   // Add a disabled permission request creator. This should not change anything.
   MockPermissionRequestCreator* creator = new MockPermissionRequestCreator;
   supervised_user_service_->AddPermissionRequestCreator(
       make_scoped_ptr(creator));
 
   EXPECT_FALSE(supervised_user_service_->AccessRequestsEnabled());
   {
     AsyncResultHolder result_holder;
-    AddAccessRequest(url, &result_holder);
+    AddURLAccessRequest(url, &result_holder);
     EXPECT_FALSE(result_holder.GetResult());
   }
 
   // Enable the permission request creator. This should enable permission
   // requests and queue them up.
   creator->set_enabled(true);
   EXPECT_TRUE(supervised_user_service_->AccessRequestsEnabled());
   {
     AsyncResultHolder result_holder;
-    AddAccessRequest(url, &result_holder);
+    AddURLAccessRequest(url, &result_holder);
     ASSERT_EQ(1u, creator->requested_urls().size());
     EXPECT_EQ(url.spec(), creator->requested_urls()[0].spec());
 
     creator->AnswerRequest(0, true);
     EXPECT_TRUE(result_holder.GetResult());
   }
 
   {
     AsyncResultHolder result_holder;
-    AddAccessRequest(url, &result_holder);
+    AddURLAccessRequest(url, &result_holder);
     ASSERT_EQ(1u, creator->requested_urls().size());
     EXPECT_EQ(url.spec(), creator->requested_urls()[0].spec());
 
     creator->AnswerRequest(0, false);
     EXPECT_FALSE(result_holder.GetResult());
   }
 
   // Add a second permission request creator.
   MockPermissionRequestCreator* creator_2 = new MockPermissionRequestCreator;
   creator_2->set_enabled(true);
   supervised_user_service_->AddPermissionRequestCreator(
       make_scoped_ptr(creator_2));
 
   {
     AsyncResultHolder result_holder;
-    AddAccessRequest(url, &result_holder);
+    AddURLAccessRequest(url, &result_holder);
     ASSERT_EQ(1u, creator->requested_urls().size());
     EXPECT_EQ(url.spec(), creator->requested_urls()[0].spec());
 
     // Make the first creator succeed. This should make the whole thing succeed.
     creator->AnswerRequest(0, true);
     EXPECT_TRUE(result_holder.GetResult());
   }
 
   {
     AsyncResultHolder result_holder;
-    AddAccessRequest(url, &result_holder);
+    AddURLAccessRequest(url, &result_holder);
     ASSERT_EQ(1u, creator->requested_urls().size());
     EXPECT_EQ(url.spec(), creator->requested_urls()[0].spec());
 
     // Make the first creator fail. This should fall back to the second one.
     creator->AnswerRequest(0, false);
     ASSERT_EQ(1u, creator_2->requested_urls().size());
     EXPECT_EQ(url.spec(), creator_2->requested_urls()[0].spec());
 
     // Make the second creator succeed, which will make the whole thing succeed.
     creator_2->AnswerRequest(0, true);
@@ skipping 225 matching lines @@
   ASSERT_EQ(1u, site_list_observer_.sites().size());
   EXPECT_EQ(base::ASCIIToUTF16("Moose"), site_list_observer_.sites()[0].name);
 
   url_filter_observer_.Wait();
   EXPECT_EQ(SupervisedUserURLFilter::WARN,
             url_filter->GetFilteringBehaviorForURL(example_url));
   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
             url_filter->GetFilteringBehaviorForURL(moose_url));
 }
 #endif  // defined(ENABLE_EXTENSIONS)