service worker: use 200 OK for update requests even in the no update case

content/browser/service_worker/embedded_worker_instance.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/embedded_worker_instance.h"
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/macros.h"
@@ skipping 309 matching lines @@
   EmbeddedWorkerInstance* instance_;
 
   StatusCallback start_callback_;
   ProcessAllocationState state_;
 
   base::WeakPtrFactory<StartTask> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(StartTask);
 };
 
+bool EmbeddedWorkerInstance::Listener::OnMessageReceived(
+    const IPC::Message& message) {
+  return false;
+}
+
 EmbeddedWorkerInstance::~EmbeddedWorkerInstance() {
   DCHECK(status_ == STOPPING || status_ == STOPPED) << status_;
   devtools_proxy_.reset();
   if (registry_->GetWorker(embedded_worker_id_))
     registry_->RemoveWorker(process_id(), embedded_worker_id_);
   process_handle_.reset();
 }
 
 void EmbeddedWorkerInstance::Start(int64_t service_worker_version_id,
                                    const GURL& scope,
                                    const GURL& script_url,
-                                   const StatusCallback& callback) {
+                                   const StatusCallback& callback,
+                                   bool pause_after_download) {
   if (!context_) {
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     // |this| may be destroyed by the callback.
     return;
   }
   DCHECK(status_ == STOPPED);
 
   // TODO(horo): If we will see crashes here, we have to find the root cause of
   // the invalid version ID. Otherwise change CHECK to DCHECK.
   CHECK_NE(service_worker_version_id, kInvalidServiceWorkerVersionId);
   start_timing_ = base::TimeTicks::Now();
   status_ = STARTING;
   starting_phase_ = ALLOCATING_PROCESS;
   network_accessed_for_script_ = false;
   service_registry_.reset(new ServiceRegistryImpl());
   FOR_EACH_OBSERVER(Listener, listener_list_, OnStarting());
 
   scoped_ptr<EmbeddedWorkerMsg_StartWorker_Params> params(
       new EmbeddedWorkerMsg_StartWorker_Params());
   params->embedded_worker_id = embedded_worker_id_;
   params->service_worker_version_id = service_worker_version_id;
   params->scope = scope;
   params->script_url = script_url;
   params->worker_devtools_agent_route_id = MSG_ROUTING_NONE;
   params->wait_for_debugger = false;
+  params->pause_after_download = pause_after_download;
   params->v8_cache_options = GetV8CacheOptions();
 
   inflight_start_task_.reset(new StartTask(this));
   inflight_start_task_->Start(std::move(params), callback);
 }
 
 ServiceWorkerStatusCode EmbeddedWorkerInstance::Stop() {
   DCHECK(status_ == STARTING || status_ == RUNNING) << status_;
 
   // Abort an inflight start task.
@@ skipping 27 matching lines @@
 ServiceWorkerStatusCode EmbeddedWorkerInstance::SendMessage(
     const IPC::Message& message) {
   DCHECK_NE(kInvalidEmbeddedWorkerThreadId, thread_id_);
   if (status_ != RUNNING && status_ != STARTING)
     return SERVICE_WORKER_ERROR_IPC_FAILED;
   return registry_->Send(process_id(),
                          new EmbeddedWorkerContextMsg_MessageToWorker(
                              thread_id_, embedded_worker_id_, message));
 }
 
+void EmbeddedWorkerInstance::ResumeAfterDownload() {
+  if (process_id() == ChildProcessHost::kInvalidUniqueID)

[nhiroki, 2016/02/10 04:56:14]

We may also need to check |status_| like this:

if (process_id() == CPH::kInvalidUniqueID || status_ != STARTING)
  return;

because the worker in STOPPING state could have a valid |process_handle_|.

[falken, 2016/02/10 05:40:40]

Good catch. Done.

+    return;
+  registry_->Send(process_id(), new EmbeddedWorkerMsg_ResumeAfterDownload(
+                                    embedded_worker_id_));
+}
+
 ServiceRegistry* EmbeddedWorkerInstance::GetServiceRegistry() {
   DCHECK(status_ == STARTING || status_ == RUNNING) << status_;
   return service_registry_.get();
 }
 
 EmbeddedWorkerInstance::EmbeddedWorkerInstance(
     base::WeakPtr<ServiceWorkerContextCore> context,
     int embedded_worker_id)
     : context_(context),
       registry_(context->embedded_worker_registry()),
@@ skipping 278 matching lines @@
     case SCRIPT_READ_FINISHED:
       return "Script read finished";
     case STARTING_PHASE_MAX_VALUE:
       NOTREACHED();
   }
   NOTREACHED() << phase;
   return std::string();
 }
 
 }  // namespace content