Add a status code to install event handled message from Service Worker

content/browser/service_worker/service_worker_version.cc

 // Copyright 2013 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 "base/stl_util.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 
 typedef ServiceWorkerVersion::StatusCallback StatusCallback;
 typedef ServiceWorkerVersion::MessageCallback MessageCallback;
 
 namespace {
 
+typedef base::Callback<bool(const IPC::Message* message,
+                            Tuple1<blink::WebServiceWorkerEventResult>* result)>
+    InstallPhaseEventFinishedMessageReader;
+
+// Parameters for the HandleInstallPhaseEventFinished function, which cannot
+// accept them directly without exceeding the max arity supported by Bind().
+struct HandleInstallPhaseEventFinishedParameters {
+  HandleInstallPhaseEventFinishedParameters(
+      base::WeakPtr<ServiceWorkerVersion> version,
+      uint32 expected_message_type,
+      const InstallPhaseEventFinishedMessageReader& message_reader,
+      const StatusCallback& callback,
+      ServiceWorkerVersion::Status next_status_on_success,
+      ServiceWorkerVersion::Status next_status_on_error,
+      ServiceWorkerStatusCode next_status_code_on_event_rejection)
+      : version(version),
+        expected_message_type(expected_message_type),
+        message_reader(message_reader),
+        callback(callback),
+        next_status_on_success(next_status_on_success),
+        next_status_on_error(next_status_on_error),
+        next_status_code_on_event_rejection(
+            next_status_code_on_event_rejection) {}
+
+  base::WeakPtr<ServiceWorkerVersion> version;
+  uint32 expected_message_type;
+  InstallPhaseEventFinishedMessageReader message_reader;
+  StatusCallback callback;
+  ServiceWorkerVersion::Status next_status_on_success;
+  ServiceWorkerVersion::Status next_status_on_error;
+  ServiceWorkerStatusCode next_status_code_on_event_rejection;
+};
+
 void RunSoon(const base::Closure& callback) {
   if (!callback.is_null())
     base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 template <typename CallbackArray, typename Arg>
 void RunCallbacks(CallbackArray* callbacks_ptr, const Arg& arg) {
   CallbackArray callbacks;
   callbacks.swap(*callbacks_ptr);
   for (typename CallbackArray::const_iterator i = callbacks.begin();
@@ skipping 21 matching lines @@
     return;
   }
   task.Run();
 }
 
 void RunEmptyMessageCallback(const MessageCallback& callback,
                              ServiceWorkerStatusCode status) {
   callback.Run(status, IPC::Message());
 }
 
-void HandleEventFinished(base::WeakPtr<ServiceWorkerVersion> version,
-                         uint32 expected_message_type,
-                         const StatusCallback& callback,
-                         ServiceWorkerVersion::Status next_status_on_success,
-                         ServiceWorkerVersion::Status next_status_on_error,
-                         ServiceWorkerStatusCode status,
-                         const IPC::Message& message) {
-  if (!version)
+void HandleInstallPhaseEventFinished(
+    const HandleInstallPhaseEventFinishedParameters& params,
+    ServiceWorkerStatusCode status,
+    const IPC::Message& message) {
+  if (!params.version)
     return;
   if (status != SERVICE_WORKER_OK) {
-    version->SetStatus(next_status_on_error);
-    callback.Run(status);
+    params.version->SetStatus(params.next_status_on_error);
+    params.callback.Run(status);
     return;
   }
-  if (message.type() != expected_message_type) {
+  if (message.type() != params.expected_message_type) {
     NOTREACHED() << "Got unexpected response: " << message.type()
-                 << " expected:" << expected_message_type;
-    version->SetStatus(next_status_on_error);
-    callback.Run(SERVICE_WORKER_ERROR_FAILED);
+                 << " expected:" << params.expected_message_type;
+    params.version->SetStatus(params.next_status_on_error);
+    params.callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
-  version->SetStatus(next_status_on_success);
-  callback.Run(SERVICE_WORKER_OK);
+  params.version->SetStatus(params.next_status_on_success);
+
+  Tuple1<blink::WebServiceWorkerEventResult> result(
+      blink::WebServiceWorkerEventResultCompleted);
+  if (!params.message_reader.is_null()) {
+    params.message_reader.Run(&message, &result);
+    if (result.a == blink::WebServiceWorkerEventResultRejected)
+      status = params.next_status_code_on_event_rejection;
+  }
+  params.callback.Run(status);
 }
 
 void HandleFetchResponse(const ServiceWorkerVersion::FetchCallback& callback,
                          ServiceWorkerStatusCode status,
                          const IPC::Message& message) {
   if (status != SERVICE_WORKER_OK) {
     callback.Run(status,
                  SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK,
                  ServiceWorkerResponse());
     return;
@@ skipping 144 matching lines @@
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(request_id, message);
   if (status != SERVICE_WORKER_OK) {
     message_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status, IPC::Message()));
     return;
   }
 }
 
 void ServiceWorkerVersion::DispatchInstallEvent(
-    int active_version_embedded_worker_id,
+    int active_version_id,
     const StatusCallback& callback) {
   DCHECK_EQ(NEW, status()) << status();
   SetStatus(INSTALLING);
+  HandleInstallPhaseEventFinishedParameters params(
+      weak_factory_.GetWeakPtr(),
+      ServiceWorkerHostMsg_InstallEventFinished::ID,
+      base::Bind(&ServiceWorkerHostMsg_InstallEventFinished::Read),
+      callback,
+      INSTALLED,
+      NEW,
+      SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED);
   SendMessageAndRegisterCallback(
-      ServiceWorkerMsg_InstallEvent(active_version_embedded_worker_id),
-      base::Bind(&HandleEventFinished, weak_factory_.GetWeakPtr(),
-                 ServiceWorkerHostMsg_InstallEventFinished::ID,
-                 callback, INSTALLED, NEW));
+      ServiceWorkerMsg_InstallEvent(active_version_id),
+      base::Bind(&HandleInstallPhaseEventFinished, params));
 }
 
 void ServiceWorkerVersion::DispatchActivateEvent(
     const StatusCallback& callback) {
   DCHECK_EQ(INSTALLED, status()) << status();
   SetStatus(ACTIVATING);
   // TODO(kinuko): Implement.
   NOTIMPLEMENTED();
-  RunSoon(base::Bind(&HandleEventFinished, weak_factory_.GetWeakPtr(),
-                     -1 /* dummy message_id */, callback, ACTIVE, INSTALLED,
+  HandleInstallPhaseEventFinishedParameters params(
+      weak_factory_.GetWeakPtr(),
+      -1 /* dummy message_id */,
+      InstallPhaseEventFinishedMessageReader(),
+      callback,
+      ACTIVE,
+      INSTALLED,
+      SERVICE_WORKER_ERROR_ACTIVATE_WORKER_FAILED);
+  RunSoon(base::Bind(&HandleInstallPhaseEventFinished,
+                     params,
                      SERVICE_WORKER_OK,
                      IPC::Message(-1, -1, IPC::Message::PRIORITY_NORMAL)));
 }
 
 void ServiceWorkerVersion::DispatchFetchEvent(
     const ServiceWorkerFetchRequest& request,
     const FetchCallback& callback) {
   DCHECK_EQ(ACTIVE, status()) << status();
   SendMessageAndRegisterCallback(
       ServiceWorkerMsg_FetchEvent(request),
@@ skipping 42 matching lines @@
   if (callback) {
     callback->Run(SERVICE_WORKER_OK, message);
     message_callbacks_.Remove(request_id);
     return;
   }
   NOTREACHED() << "Got unexpected message: " << request_id
                << " " << message.type();
 }
 
 }  // namespace content