Implement Web Restrictions in WebView.

components/web_restrictions/browser/web_restrictions_resource_throttle_unittest.cc

 // Copyright 2016 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/bind.h"
 #include "base/run_loop.h"
 #include "components/web_restrictions/browser/mock_web_restrictions_client.h"
 #include "components/web_restrictions/browser/web_restrictions_client.h"
 #include "components/web_restrictions/browser/web_restrictions_resource_throttle.h"
 #include "content/public/browser/resource_controller.h"
@@ skipping 42 matching lines @@
 }  // namespace
 
 class WebRestrictionsResourceThrottleTest : public testing::Test {
  protected:
   WebRestrictionsResourceThrottleTest()
       : throttle_(&provider_, GURL("http://example.com"), true),
         controller_(run_loop_.QuitClosure()) {
     throttle_.set_controller_for_testing(&controller_);
   }
 
+  void SetAuthority(std::string authority) {
+    provider_.SetAuthorityTask(authority);
+  }
+
   void StartProvider() {
-    provider_.SetAuthority("Good");
+    SetAuthority("Good");
     bool defer;
     throttle_.WillStartRequest(&defer);
     run_loop_.Run();
   }
 
   // Mock the Java WebRestrictionsClient. The real version
   // would need a content provider to do anything.
   web_restrictions::MockWebRestrictionsClient mock_;
   content::TestBrowserThreadBundle thread_bundle_;
   WebRestrictionsClient provider_;
   WebRestrictionsResourceThrottle throttle_;
   base::RunLoop run_loop_;
   TestResourceController controller_;
 };
 
 TEST_F(WebRestrictionsResourceThrottleTest, WillStartRequest_NoAuthority) {
   WebRestrictionsResourceThrottle throttle(&provider_,
                                            GURL("http://example.com"), true);
   bool defer;
   throttle.WillStartRequest(&defer);
   // If there is no authority the request won't be deferred.
   EXPECT_FALSE(defer);
 }
 
 TEST_F(WebRestrictionsResourceThrottleTest, WillStartRequest_DeferredAllow) {
   // Test deferring with a resource provider, and that the correct results
   // are received.
-  provider_.SetAuthority("Good");
+  SetAuthority("Good");
   bool defer;
   throttle_.WillStartRequest(&defer);
   EXPECT_TRUE(defer);
   run_loop_.Run();
   EXPECT_TRUE(controller_.ResumeCalled());
   EXPECT_FALSE(controller_.CancelWithErrorCalled());
 }
 
 TEST_F(WebRestrictionsResourceThrottleTest, WillStartRequest_DeferredForbid) {
-  provider_.SetAuthority("Bad");
+  SetAuthority("Bad");
   bool defer;
   throttle_.WillStartRequest(&defer);
   EXPECT_TRUE(defer);
   run_loop_.Run();
   EXPECT_FALSE(controller_.ResumeCalled());
   EXPECT_TRUE(controller_.CancelWithErrorCalled());
   EXPECT_EQ(net::ERR_BLOCKED_BY_ADMINISTRATOR, controller_.GetErrorCode());
 }
 
 TEST_F(WebRestrictionsResourceThrottleTest, WillStartRequest_Subresource) {
   // Only the main frame should be deferred.
   // Initialization of the controller is asynchronous, and this will only work
   // correctly if the provider is initialized. Run a main frame through this
   // first to ensure that everything is initialized.
   StartProvider();
   // Now the real test.
   WebRestrictionsResourceThrottle throttle(
       &provider_, GURL("http://example.com/sub"), false);
   base::RunLoop test_run_loop;
   TestResourceController test_controller(test_run_loop.QuitClosure());
   throttle.set_controller_for_testing(&test_controller);
   bool defer;
   throttle.WillStartRequest(&defer);
-  EXPECT_FALSE(defer);
+  ASSERT_FALSE(defer);
 }
 
 TEST_F(WebRestrictionsResourceThrottleTest, WillRedirectRequest_KnownUrl) {
   // Set up a cached url.
   StartProvider();
   // Using the same URL should not be deferred
   net::RedirectInfo redirect;
   redirect.new_url = GURL("http://example.com");
   bool defer;
   throttle_.WillRedirectRequest(redirect, &defer);
-  EXPECT_FALSE(defer);
+  ASSERT_FALSE(defer);
 }
 
 TEST_F(WebRestrictionsResourceThrottleTest, WillRedirectRequest_NewUrl) {
   // Set up a cached url.
   StartProvider();
   // Using a different URL should be deferred
   net::RedirectInfo redirect;
   redirect.new_url = GURL("http://example.com/2");
   base::RunLoop test_run_loop;
   TestResourceController test_controller(test_run_loop.QuitClosure());
   throttle_.set_controller_for_testing(&test_controller);
   bool defer;
   throttle_.WillRedirectRequest(redirect, &defer);
-  EXPECT_TRUE(defer);
+  ASSERT_TRUE(defer);
   // If we don't wait for the callback it may happen after the exit, which
   // results in accesses the redirect_url after the stack frame is freed.
   test_run_loop.Run();
 }
 
 }  // namespace web_restrictions