Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/policy

chrome/browser/policy/policy_browsertest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <string>
@@ skipping 324 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(FailedJobInterceptor);
 };
 
 // While |MakeRequestFail| is in scope URLRequests to |host| will fail.
 class MakeRequestFail {
  public:
   // Sets up the filter on IO thread such that requests to |host| fail.
   explicit MakeRequestFail(const std::string& host) : host_(host) {
     BrowserThread::PostTaskAndReply(BrowserThread::IO, FROM_HERE,
-                                    base::Bind(MakeRequestFailOnIO, host_),
+                                    base::BindOnce(MakeRequestFailOnIO, host_),
                                     base::MessageLoop::QuitWhenIdleClosure());
     content::RunMessageLoop();
   }
   ~MakeRequestFail() {
-    BrowserThread::PostTaskAndReply(BrowserThread::IO, FROM_HERE,
-                                    base::Bind(UndoMakeRequestFailOnIO, host_),
-                                    base::MessageLoop::QuitWhenIdleClosure());
+    BrowserThread::PostTaskAndReply(
+        BrowserThread::IO, FROM_HERE,
+        base::BindOnce(UndoMakeRequestFailOnIO, host_),
+        base::MessageLoop::QuitWhenIdleClosure());
     content::RunMessageLoop();
   }
 
  private:
   // Filters requests to the |host| such that they fail. Run on IO thread.
   static void MakeRequestFailOnIO(const std::string& host) {
     net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
     filter->AddHostnameInterceptor("http", host,
                                    std::unique_ptr<net::URLRequestInterceptor>(
                                        new FailedJobInterceptor()));
@@ skipping 267 matching lines @@
   void SetUpInProcessBrowserTestFixture() override {
     base::CommandLine::ForCurrentProcess()->AppendSwitch("noerrdialogs");
     EXPECT_CALL(provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(true));
     BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
   }
 
   void SetUpOnMainThread() override {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(chrome_browser_net::SetUrlRequestMocksEnabled, true));
+        base::BindOnce(chrome_browser_net::SetUrlRequestMocksEnabled, true));
     if (extension_service()->updater()) {
       extension_service()->updater()->SetExtensionCacheForTesting(
           test_extension_cache_.get());
     }
   }
 
   // Makes URLRequestMockHTTPJobs serve data from content::DIR_TEST_DATA
   // instead of chrome::DIR_TEST_DATA.
   void ServeContentTestData() {
     base::FilePath root_http;
     PathService::Get(content::DIR_TEST_DATA, &root_http);
     BrowserThread::PostTaskAndReply(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(URLRequestMockHTTPJob::AddUrlHandlers, root_http,
-                   make_scoped_refptr(BrowserThread::GetBlockingPool())),
+        base::BindOnce(URLRequestMockHTTPJob::AddUrlHandlers, root_http,
+                       make_scoped_refptr(BrowserThread::GetBlockingPool())),
         base::MessageLoop::current()->QuitWhenIdleClosure());
     content::RunMessageLoop();
   }
 
   void SetScreenshotPolicy(bool enabled) {
     PolicyMap policies;
     policies.Set(key::kDisableScreenshots, POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
                  base::MakeUnique<base::Value>(!enabled), nullptr);
     UpdateProviderPolicy(policies);
@@ skipping 574 matching lines @@
 void GetPacHttpsUrlStrippingEnabledOnIOThread(IOThread* io_thread,
                                               bool* enabled) {
   *enabled = io_thread->PacHttpsUrlStrippingEnabled();
 }
 
 bool GetPacHttpsUrlStrippingEnabled() {
   bool enabled;
   base::RunLoop loop;
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&GetPacHttpsUrlStrippingEnabledOnIOThread,
-                 g_browser_process->io_thread(), base::Unretained(&enabled)),
+      base::BindOnce(&GetPacHttpsUrlStrippingEnabledOnIOThread,
+                     g_browser_process->io_thread(),
+                     base::Unretained(&enabled)),
       loop.QuitClosure());
   loop.Run();
   return enabled;
 }
 
 }  // namespace
 
 // Verifies that stripping of https:// URLs before sending to PAC scripts can
 // be disabled via a policy. Also verifies that stripping is enabled by
 // default.
@@ skipping 1083 matching lines @@
     "http://aaa.com/empty.html",
     "http://bbb.com/empty.html",
     "http://sub.bbb.com/empty.html",
     "http://bbb.com/policy/blank.html",
     "http://bbb.com./policy/blank.html",
   };
   {
     base::RunLoop loop;
     BrowserThread::PostTaskAndReply(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(RedirectHostsToTestData, kURLS, arraysize(kURLS)),
+        base::BindOnce(RedirectHostsToTestData, kURLS, arraysize(kURLS)),
         loop.QuitClosure());
     loop.Run();
   }
 
   // Verify that "bbb.com" opens before applying the blacklist.
   CheckCanOpenURL(browser(), kURLS[1]);
 
   // Set a blacklist.
   base::ListValue blacklist;
   blacklist.AppendString("bbb.com");
@@ skipping 17 matching lines @@
   FlushBlacklistPolicy();
   CheckURLIsBlocked(browser(), kURLS[1]);
   CheckCanOpenURL(browser(), kURLS[2]);
   CheckCanOpenURL(browser(), kURLS[3]);
   CheckCanOpenURL(browser(), kURLS[4]);
 
   {
     base::RunLoop loop;
     BrowserThread::PostTaskAndReply(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(UndoRedirectHostsToTestData, kURLS, arraysize(kURLS)),
+        base::BindOnce(UndoRedirectHostsToTestData, kURLS, arraysize(kURLS)),
         loop.QuitClosure());
     loop.Run();
   }
 }
 
 IN_PROC_BROWSER_TEST_F(PolicyTest, URLBlacklistSubresources) {
   // Checks that an image with a blacklisted URL is loaded, but an iframe with a
   // blacklisted URL is not.
 
   GURL main_url =
@@ skipping 550 matching lines @@
     base::CommandLine::StringVector argv = command_line->argv();
     argv.erase(std::remove_if(++argv.begin(), argv.end(), IsNonSwitchArgument),
                argv.end());
     command_line->InitFromArgv(argv);
     ASSERT_TRUE(std::equal(argv.begin(), argv.end(),
                            command_line->argv().begin()));
   }
 
   void SetUpOnMainThread() override {
     BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(
-            RedirectHostsToTestData, kRestoredURLs, arraysize(kRestoredURLs)));
+        BrowserThread::IO, FROM_HERE,
+        base::BindOnce(RedirectHostsToTestData, kRestoredURLs,
+                       arraysize(kRestoredURLs)));
   }
 
   void ListOfURLs() {
     // Verifies that policy can set the startup pages to a list of URLs.
     base::ListValue urls;
     for (size_t i = 0; i < arraysize(kRestoredURLs); ++i) {
       urls.AppendString(kRestoredURLs[i]);
       expected_urls_.push_back(GURL(kRestoredURLs[i]));
     }
     PolicyMap policies;
@@ skipping 287 matching lines @@
   content::MediaStreamDevice fake_audio_device(
       content::MEDIA_DEVICE_AUDIO_CAPTURE, "fake_dev", "Fake Audio Device");
   audio_devices.push_back(fake_audio_device);
 
   PolicyMap policies;
   ConfigurePolicyMap(&policies, key::kAudioCaptureAllowed, NULL, NULL);
   UpdateProviderPolicy(policies);
 
   content::BrowserThread::PostTaskAndReply(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&MediaCaptureDevicesDispatcher::SetTestAudioCaptureDevices,
-                 base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
-                 audio_devices),
-      base::Bind(&MediaStreamDevicesControllerBrowserTest::FinishAudioTest,
-                 base::Unretained(this)));
+      base::BindOnce(
+          &MediaCaptureDevicesDispatcher::SetTestAudioCaptureDevices,
+          base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
+          audio_devices),
+      base::BindOnce(&MediaStreamDevicesControllerBrowserTest::FinishAudioTest,
+                     base::Unretained(this)));
 
   base::RunLoop().Run();
 }
 
 IN_PROC_BROWSER_TEST_P(MediaStreamDevicesControllerBrowserTest,
                        AudioCaptureAllowedUrls) {
   content::MediaStreamDevices audio_devices;
   content::MediaStreamDevice fake_audio_device(
       content::MEDIA_DEVICE_AUDIO_CAPTURE, "fake_dev", "Fake Audio Device");
   audio_devices.push_back(fake_audio_device);
 
   const char* allow_pattern[] = {
     kExampleRequestPattern,
     // This will set an allow-all policy whitelist.  Since we do not allow
     // setting an allow-all entry in the whitelist, this entry should be ignored
     // and therefore the request should be denied.
     NULL,
   };
 
   for (size_t i = 0; i < arraysize(allow_pattern); ++i) {
     PolicyMap policies;
     ConfigurePolicyMap(&policies, key::kAudioCaptureAllowed,
                        key::kAudioCaptureAllowedUrls, allow_pattern[i]);
     UpdateProviderPolicy(policies);
 
     content::BrowserThread::PostTaskAndReply(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(
+        base::BindOnce(
             &MediaCaptureDevicesDispatcher::SetTestAudioCaptureDevices,
             base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
             audio_devices),
-        base::Bind(
+        base::BindOnce(
             &MediaStreamDevicesControllerBrowserTest::FinishAudioTest,
             base::Unretained(this)));
 
     base::RunLoop().Run();
   }
 }
 
 IN_PROC_BROWSER_TEST_P(MediaStreamDevicesControllerBrowserTest,
                        VideoCaptureAllowed) {
   content::MediaStreamDevices video_devices;
   content::MediaStreamDevice fake_video_device(
       content::MEDIA_DEVICE_VIDEO_CAPTURE, "fake_dev", "Fake Video Device");
   video_devices.push_back(fake_video_device);
 
   PolicyMap policies;
   ConfigurePolicyMap(&policies, key::kVideoCaptureAllowed, NULL, NULL);
   UpdateProviderPolicy(policies);
 
   content::BrowserThread::PostTaskAndReply(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices,
-                 base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
-                 video_devices),
-      base::Bind(&MediaStreamDevicesControllerBrowserTest::FinishVideoTest,
-                 base::Unretained(this)));
+      base::BindOnce(
+          &MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices,
+          base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
+          video_devices),
+      base::BindOnce(&MediaStreamDevicesControllerBrowserTest::FinishVideoTest,
+                     base::Unretained(this)));
 
   base::RunLoop().Run();
 }
 
 IN_PROC_BROWSER_TEST_P(MediaStreamDevicesControllerBrowserTest,
                        VideoCaptureAllowedUrls) {
   content::MediaStreamDevices video_devices;
   content::MediaStreamDevice fake_video_device(
       content::MEDIA_DEVICE_VIDEO_CAPTURE, "fake_dev", "Fake Video Device");
   video_devices.push_back(fake_video_device);
 
   const char* allow_pattern[] = {
     kExampleRequestPattern,
     // This will set an allow-all policy whitelist.  Since we do not allow
     // setting an allow-all entry in the whitelist, this entry should be ignored
     // and therefore the request should be denied.
     NULL,
   };
 
   for (size_t i = 0; i < arraysize(allow_pattern); ++i) {
     PolicyMap policies;
     ConfigurePolicyMap(&policies, key::kVideoCaptureAllowed,
                        key::kVideoCaptureAllowedUrls, allow_pattern[i]);
     UpdateProviderPolicy(policies);
 
     content::BrowserThread::PostTaskAndReply(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices,
+        base::BindOnce(
+            &MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices,
             base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
             video_devices),
-        base::Bind(
+        base::BindOnce(
             &MediaStreamDevicesControllerBrowserTest::FinishVideoTest,
             base::Unretained(this)));
 
     base::RunLoop().Run();
   }
 }
 
 INSTANTIATE_TEST_CASE_P(MediaStreamDevicesControllerBrowserTestInstance,
                         MediaStreamDevicesControllerBrowserTest,
                         testing::Bool());
@@ skipping 58 matching lines @@
                  nullptr)));
 
   net::EmbeddedTestServer https_server_ok(net::EmbeddedTestServer::TYPE_HTTPS);
   https_server_ok.SetSSLConfig(net::EmbeddedTestServer::CERT_OK);
   https_server_ok.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server_ok.Start());
 
   // Require CT for all hosts (in the absence of policy).
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(net::TransportSecurityState::SetShouldRequireCTForTesting,
-                 base::Owned(new bool(true))));
+      base::BindOnce(net::TransportSecurityState::SetShouldRequireCTForTesting,
+                     base::Owned(new bool(true))));
 
   ui_test_utils::NavigateToURL(browser(), https_server_ok.GetURL("/"));
 
   // The page should initially be blocked.
   const content::InterstitialPage* interstitial =
       content::InterstitialPage::GetInterstitialPage(
           browser()->tab_strip_model()->GetActiveWebContents());
   ASSERT_TRUE(interstitial);
   ASSERT_TRUE(content::WaitForRenderFrameReady(interstitial->GetMainFrame()));
 
@@ skipping 433 matching lines @@
   EXPECT_TRUE(post_interceptor_->ExpectRequest(
       new update_client::PartialMatch("updatecheck"), 200));
   EXPECT_TRUE(cus_->RegisterComponent(crx_component));
   cus_->GetOnDemandUpdater().OnDemandUpdate(
       component_id_, base::Bind(&ComponentUpdaterPolicyTest::OnDemandComplete,
                                 base::Unretained(this)));
 }
 
 void ComponentUpdaterPolicyTest::CallAsync(TestCaseAction action) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::Bind(action, base::Unretained(this)));
+                          base::BindOnce(action, base::Unretained(this)));
 }
 
 void ComponentUpdaterPolicyTest::OnDemandComplete(update_client::Error error) {
   CallAsync(cur_test_case_.second);
 }
 
 void ComponentUpdaterPolicyTest::BeginTest() {
   cus_ = g_browser_process->component_updater();
 
   const auto config = component_updater::MakeChromeComponentUpdaterConfigurator(
@@ skipping 573 matching lines @@
 
   SetEmptyPolicy();
   // Policy not set.
   CheckSystemTimezoneAutomaticDetectionPolicyUnset();
   EXPECT_TRUE(CheckResolveTimezoneByGeolocation(true, false));
   EXPECT_TRUE(manager->TimeZoneResolverShouldBeRunningForTests());
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace policy