Enable use_once_callback for //content/common/*.mojom

content/browser/service_worker/service_worker_version_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 "content/browser/service_worker/service_worker_version.h"
 
 #include <stdint.h>
 #include <tuple>
 
 #include "base/macros.h"
@@ skipping 816 matching lines @@
   EXPECT_EQ(run_time, version_->update_timer_.desired_run_time());
 }
 
 class MessageReceiverControlEvents : public MessageReceiver {
  public:
   MessageReceiverControlEvents() : MessageReceiver() {}
   ~MessageReceiverControlEvents() override {}
 
   void OnExtendableMessageEvent(
       mojom::ExtendableMessageEventPtr event,
-      const mojom::ServiceWorkerEventDispatcher::
-          DispatchExtendableMessageEventCallback& callback) override {
+      mojom::ServiceWorkerEventDispatcher::
+          DispatchExtendableMessageEventCallback callback) override {
     EXPECT_FALSE(extendable_message_event_callback_);
-    extendable_message_event_callback_ = callback;
+    extendable_message_event_callback_ = std::move(callback);
   }
 
   void OnStopWorker(int embedded_worker_id) override {
     EXPECT_FALSE(stop_worker_callback_);
     stop_worker_callback_ =
         base::Bind(&MessageReceiverControlEvents::SimulateWorkerStopped,
                    base::Unretained(this), embedded_worker_id);
   }
 
-  const mojom::ServiceWorkerEventDispatcher::
-      DispatchExtendableMessageEventCallback&
-      extendable_message_event_callback() {
-    return extendable_message_event_callback_;
+  bool has_extendable_message_event_callback() {
+    return !extendable_message_event_callback_.is_null();
+  }
+
+  mojom::ServiceWorkerEventDispatcher::DispatchExtendableMessageEventCallback
+  TakeExtendableMessageEventCallback() {
+    return std::move(extendable_message_event_callback_);
   }
 
   const base::Closure& stop_worker_callback() { return stop_worker_callback_; }
 
  private:
   mojom::ServiceWorkerEventDispatcher::DispatchExtendableMessageEventCallback
       extendable_message_event_callback_;
   base::Closure stop_worker_callback_;
 };
 
 class ServiceWorkerRequestTimeoutTest : public ServiceWorkerVersionTest {
  protected:
   ServiceWorkerRequestTimeoutTest() : ServiceWorkerVersionTest() {}
 
   std::unique_ptr<MessageReceiver> GetMessageReceiver() override {
     return base::MakeUnique<MessageReceiverControlEvents>();
   }
 
-  const mojom::ServiceWorkerEventDispatcher::
-      DispatchExtendableMessageEventCallback&
-      extendable_message_event_callback() {
+  bool has_extendable_message_event_callback() {
     return static_cast<MessageReceiverControlEvents*>(helper_.get())
-        ->extendable_message_event_callback();
+        ->has_extendable_message_event_callback();
+  }
+
+  mojom::ServiceWorkerEventDispatcher::DispatchExtendableMessageEventCallback
+  TakeExtendableMessageEventCallback() {
+    return static_cast<MessageReceiverControlEvents*>(helper_.get())
+        ->TakeExtendableMessageEventCallback();
   }
 
   const base::Closure& stop_worker_callback() {
     return static_cast<MessageReceiverControlEvents*>(helper_.get())
         ->stop_worker_callback();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerRequestTimeoutTest);
 };
 
 TEST_F(ServiceWorkerRequestTimeoutTest, RequestTimeout) {
   ServiceWorkerStatusCode error_status =
       SERVICE_WORKER_ERROR_NETWORK;  // dummy value
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
 
   version_->StartWorker(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME,
                         base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   base::RunLoop().RunUntilIdle();
 
   // Create a request.
   int request_id =
       version_->StartRequest(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME,
                              CreateReceiverOnCurrentThread(&error_status));
 
   // Dispatch a dummy event whose response will be received by SWVersion.
-  EXPECT_FALSE(extendable_message_event_callback());
+  EXPECT_FALSE(has_extendable_message_event_callback());
   version_->event_dispatcher()->DispatchExtendableMessageEvent(
       mojom::ExtendableMessageEvent::New(),
       version_->CreateSimpleEventCallback(request_id));
 
   base::RunLoop().RunUntilIdle();
   // The renderer should have received an ExtendableMessageEvent request.
-  EXPECT_TRUE(extendable_message_event_callback());
+  EXPECT_TRUE(has_extendable_message_event_callback());
 
   // Callback has not completed yet.
   EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, error_status);
   EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status());
 
   // Simulate timeout.
   EXPECT_FALSE(stop_worker_callback());
   EXPECT_TRUE(version_->timeout_timer_.IsRunning());
   version_->SetAllRequestExpirations(base::TimeTicks::Now());
   version_->timeout_timer_.user_task().Run();
   base::RunLoop().RunUntilIdle();
 
   // The renderer should have received a StopWorker request.
   EXPECT_TRUE(stop_worker_callback());
   // The request should have timed out.
   EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, error_status);
   // Calling FinishRequest should be no-op, since the request timed out.
   EXPECT_FALSE(version_->FinishRequest(request_id, true /* was_handled */,
                                        base::Time::Now()));
 
   // Simulate the renderer aborting the pending event.
   // This should not crash: https://crbug.com/676984.
-  extendable_message_event_callback().Run(SERVICE_WORKER_ERROR_ABORT,
-                                          base::Time::Now());
+  TakeExtendableMessageEventCallback().Run(SERVICE_WORKER_ERROR_ABORT,
+                                           base::Time::Now());
   base::RunLoop().RunUntilIdle();
 
   // Simulate the renderer stopping the worker.
   stop_worker_callback().Run();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status());
 }
 
 TEST_F(ServiceWorkerVersionTest, RequestNowTimeout) {
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK;  // dummy value
@@ skipping 666 matching lines @@
   // Should not have timed out, so error callback should not have been
   // called and FinishRequest should return true.
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_TRUE(version_->FinishRequest(request_id1, true /* was_handled */,
                                       base::Time::Now()));
   EXPECT_TRUE(version_->FinishRequest(request_id2, true /* was_handled */,
                                       base::Time::Now()));
 }
 
 }  // namespace content