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"
@@ skipping 67 matching lines @@
     NOTREACHED() << "Got unexpected response: " << message.type()
                  << " expected:" << expected_message_type;
     version->SetStatus(next_status_on_error);
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   version->SetStatus(next_status_on_success);
   callback.Run(SERVICE_WORKER_OK);
 }
 
+void HandleInstallEventFinished(base::WeakPtr<ServiceWorkerVersion> version,

[kinuko, 2014/03/25 11:16:49]

I think we'll want to use this too for activate event (since it aksi has
waitUntil). Can we not fork this from HandleEventFinished but just revise it for
now?  (In order to make it clearer that the method is for handling
InstallPhaseEvent family it might be better to rename it to
HandleInstallPhaseEvent too)

[falken, 2014/03/26 07:53:56]

Done.

+                                const StatusCallback& callback,
+                                ServiceWorkerStatusCode status,
+                                const IPC::Message& message) {
+  if (status != SERVICE_WORKER_OK) {
+    version->SetStatus(ServiceWorkerVersion::NEW);
+    callback.Run(status);
+    return;
+  }
+  if (message.type() != ServiceWorkerHostMsg_InstallEventFinished::ID) {
+    NOTREACHED() << "Got unexpected response for InstallEvent: "
+                 << message.type();
+    version->SetStatus(ServiceWorkerVersion::NEW);
+    callback.Run(SERVICE_WORKER_ERROR_FAILED);
+    return;
+  }
+  Tuple1<ServiceWorkerInstallEventResult> result;
+  ServiceWorkerHostMsg_InstallEventFinished::Read(&message, &result);
+  if (result.a == SERVICE_WORKER_INSTALL_EVENT_RESULT_REJECTED)
+    status = SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED;
+  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;
   }
   if (message.type() != ServiceWorkerHostMsg_FetchEventFinished::ID) {
@@ skipping 148 matching lines @@
   }
 }
 
 void ServiceWorkerVersion::DispatchInstallEvent(
     int active_version_embedded_worker_id,
     const StatusCallback& callback) {
   DCHECK_EQ(NEW, status()) << status();
   SetStatus(INSTALLING);
   SendMessageAndRegisterCallback(
       ServiceWorkerMsg_InstallEvent(active_version_embedded_worker_id),
-      base::Bind(&HandleEventFinished, weak_factory_.GetWeakPtr(),
-                 ServiceWorkerHostMsg_InstallEventFinished::ID,
-                 callback, INSTALLED, NEW));
+      base::Bind(
+          &HandleInstallEventFinished, weak_factory_.GetWeakPtr(), callback));
 }
 
 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,
@@ skipping 52 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