[Extensions] Cleanup: Use OnceCallback in WakeEventPage function.

Bug: None
Test: None, internal only cleanup.
Change-Id: I5e29e662450c6b7a5ee14d332caa1d76ea14b7b1
Reviewed-on: https://chromium-review.googlesource.com/1144538Reviewed-by: mark a. foltz <mfoltz@chromium.org>
Commit-Queue: Istiaque Ahmed <lazyboy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#587847}

chrome/browser/media/router/event_page_request_manager.cc

@@ -134,8 +134,8 @@ void EventPageRequestManager::AttemptWakeEventPage() {
   // |this|.
   if (!event_page_tracker_->WakeEventPage(
           media_route_provider_extension_id_,
-          base::Bind(&EventPageRequestManager::OnWakeComplete,
-                     weak_factory_.GetWeakPtr()))) {
+          base::BindOnce(&EventPageRequestManager::OnWakeComplete,
+                         weak_factory_.GetWeakPtr()))) {
     DLOG(ERROR) << "Failed to schedule a wakeup for event page.";
   }
 }

chrome/browser/media/router/event_page_request_manager_unittest.cc

@@ -52,7 +52,7 @@ class TestProcessManager : public extensions::ProcessManager {
   MOCK_METHOD1(IsEventPageSuspended, bool(const std::string& ext_id));
   MOCK_METHOD2(WakeEventPage,
                bool(const std::string& extension_id,
-                    const base::Callback<void(bool)>& callback));
+                    base::OnceCallback<void(bool)> callback));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestProcessManager);
@@ -141,11 +141,11 @@ TEST_F(EventPageRequestManagerTest, RunRequestsOnConnectionsReady) {
   ON_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
       .WillByDefault(Return(true));
   EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
-      .WillOnce(Invoke([](const std::string& extension_id,
-                          const base::Callback<void(bool)>& callback) {
-        callback.Run(true);
+      .WillOnce([](const std::string& extension_id,
+                   base::OnceCallback<void(bool)> callback) {
+        std::move(callback).Run(true);
         return true;
-      }));
+      });
   request_manager_->RunOrDefer(
       base::BindOnce(&MockRequest::Run, base::Unretained(&request1)),
       MediaRouteProviderWakeReason::DETACH_ROUTE);
@@ -185,18 +185,20 @@ TEST_F(EventPageRequestManagerTest, FailedWakeupDrainsQueue) {
   StrictMock<MockRequest> request1;
   StrictMock<MockRequest> request2;
 
-  base::Callback<void(bool)> extension_wakeup_callback;
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
       .WillOnce(Return(true));
   EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
-      .WillOnce(
-          testing::DoAll(SaveArg<1>(&extension_wakeup_callback), Return(true)));
+      .WillOnce([](const std::string& extension_id,
+                   base::OnceCallback<void(bool)> callback) {
+        // Run the callback with false to indicate that the wakeup failed.
+        // This call drains the request queue, so |request1| won't be
+        // called.
+        std::move(callback).Run(false);
+        return true;
+      });
   request_manager_->RunOrDefer(
       base::BindOnce(&MockRequest::Run, base::Unretained(&request1)),
       MediaRouteProviderWakeReason::CREATE_ROUTE);
-  // Run the callback with false to indicate that the wakeup failed. This call
-  // drains the request queue, so |request1| won't be called.
-  extension_wakeup_callback.Run(false);
 
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
       .WillRepeatedly(Return(false));

chrome/browser/media/router/test/media_router_mojo_test.h

@@ -194,7 +194,7 @@ class MockEventPageTracker : public extensions::EventPageTracker {
   MOCK_METHOD1(IsEventPageSuspended, bool(const std::string& extension_id));
   MOCK_METHOD2(WakeEventPage,
                bool(const std::string& extension_id,
-                    const base::Callback<void(bool)>& callback));
+                    base::OnceCallback<void(bool)> callback));
 };
 
 class MockEventPageRequestManager : public EventPageRequestManager {

extensions/browser/event_page_tracker.h

@@ -7,15 +7,15 @@
 
 #include <string>
 
-#include "base/callback.h"
+#include "base/callback_forward.h"
 
 namespace extensions {
 
 // Tracks an extension's event page suspend state.
 class EventPageTracker {
  public:
-  // Returns true if an extension's event page is active,
-  // or false if it is suspended.
+  // Returns true if an extension's event page is suspended,
+  // or false if it is active.
   virtual bool IsEventPageSuspended(const std::string& extension_id) = 0;
 
   // Wakes an extension's event page from a suspended state and calls
@@ -28,7 +28,7 @@ class EventPageTracker {
   // or false if the event page was already awake.
   // Callback will be run asynchronously if true, and never run if false.
   virtual bool WakeEventPage(const std::string& extension_id,
-                             const base::Callback<void(bool)>& callback) = 0;
+                             base::OnceCallback<void(bool)> callback) = 0;
 };
 
 }  // namespace extensions

extensions/browser/extension_message_filter.cc

@@ -359,8 +359,8 @@ void ExtensionMessageFilter::OnExtensionWakeEventPage(
     if (process_manager->IsEventPageSuspended(extension_id)) {
       process_manager->WakeEventPage(
           extension_id,
-          base::Bind(&ExtensionMessageFilter::SendWakeEventPageResponse, this,
-                     request_id));
+          base::BindOnce(&ExtensionMessageFilter::SendWakeEventPageResponse,
+                         this, request_id));
     } else {
       SendWakeEventPageResponse(request_id, true);
     }

extensions/browser/process_manager.cc

@@ -114,9 +114,9 @@ static void CreateBackgroundHostForExtensionLoad(
                                   BackgroundInfo::GetBackgroundURL(extension));
 }
 
-void PropagateExtensionWakeResult(const base::Callback<void(bool)>& callback,
+void PropagateExtensionWakeResult(base::OnceCallback<void(bool)> callback,
                                   extensions::ExtensionHost* host) {
-  callback.Run(host != nullptr);
+  std::move(callback).Run(host != nullptr);
 }
 
 }  // namespace
@@ -426,16 +426,16 @@ bool ProcessManager::IsEventPageSuspended(const std::string& extension_id) {
 }
 
 bool ProcessManager::WakeEventPage(const std::string& extension_id,
-                                   const base::Callback<void(bool)>& callback) {
+                                   base::OnceCallback<void(bool)> callback) {
   if (GetBackgroundHostForExtension(extension_id)) {
-    // Run the callback immediately if the extension is already awake.
+    // The extension is already awake.
     return false;
   }
   LazyBackgroundTaskQueue* queue =
       LazyBackgroundTaskQueue::Get(browser_context_);
   queue->AddPendingTask(
       browser_context_, extension_id,
-      base::BindOnce(&PropagateExtensionWakeResult, callback));
+      base::BindOnce(&PropagateExtensionWakeResult, std::move(callback)));
   return true;
 }
 

extensions/browser/process_manager.h

@@ -168,7 +168,7 @@ class ProcessManager : public KeyedService,
   // EventPageTracker implementation.
   bool IsEventPageSuspended(const std::string& extension_id) override;
   bool WakeEventPage(const std::string& extension_id,
-                     const base::Callback<void(bool)>& callback) override;
+                     base::OnceCallback<void(bool)> callback) override;
 
   // Sets the time in milliseconds that an extension event page can
   // be idle before it is shut down; must be > 0.