ServiceWorker: Store the existence of fetch event handler

content/browser/service_worker/service_worker_job_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 <stdint.h>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 1396 matching lines @@
  public:
   EventCallbackHelper()
       : EmbeddedWorkerTestHelper(base::FilePath()),
         install_event_result_(blink::WebServiceWorkerEventResultCompleted),
         activate_event_result_(blink::WebServiceWorkerEventResultCompleted) {}
 
   void OnInstallEvent(int embedded_worker_id,
                       int request_id) override {
     if (!install_callback_.is_null())
       install_callback_.Run();
-    SimulateSend(
-        new ServiceWorkerHostMsg_InstallEventFinished(
-            embedded_worker_id, request_id, install_event_result_));
+    SimulateSend(new ServiceWorkerHostMsg_InstallEventFinished(
+        embedded_worker_id, request_id, install_event_result_,
+        has_fetch_handler_));
   }
   void OnActivateEvent(int embedded_worker_id, int request_id) override {
     SimulateSend(
         new ServiceWorkerHostMsg_ActivateEventFinished(
             embedded_worker_id, request_id, activate_event_result_));
   }
 
   void set_install_callback(const base::Closure& callback) {
     install_callback_ = callback;
   }
   void set_install_event_result(blink::WebServiceWorkerEventResult result) {
     install_event_result_ = result;
   }
   void set_activate_event_result(blink::WebServiceWorkerEventResult result) {
     activate_event_result_ = result;
   }
+  void set_has_fetch_handler(bool has_fetch_handler) {
+    has_fetch_handler_ = has_fetch_handler;
+  }
 
  private:
   base::Closure install_callback_;
   blink::WebServiceWorkerEventResult install_event_result_;
   blink::WebServiceWorkerEventResult activate_event_result_;
+  bool has_fetch_handler_ = true;
 };
 
 TEST_F(ServiceWorkerJobTest, RemoveControlleeDuringInstall) {
   EventCallbackHelper* helper = new EventCallbackHelper;
   helper_.reset(helper);
 
   GURL pattern("http://www.example.com/one/");
   GURL script1("http://www.example.com/service_worker.js");
   GURL script2("http://www.example.com/service_worker.js?new");
 
@@ skipping 94 matching lines @@
   // Verify the registration remains.
   EXPECT_FALSE(registration->is_uninstalling());
   EXPECT_FALSE(registration->is_uninstalled());
 
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, old_version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, old_version->status());
 
   FindRegistrationForPattern(pattern, SERVICE_WORKER_OK);
 }
 
+TEST_F(ServiceWorkerJobTest, HasFetchHandler) {
+  EventCallbackHelper* helper = new EventCallbackHelper;
+  helper_.reset(helper);
+
+  GURL pattern("http://www.example.com/");
+  GURL script("http://www.example.com/service_worker.js");
+  scoped_refptr<ServiceWorkerRegistration> registration;
+  scoped_refptr<ServiceWorkerVersion> version;
+
+  helper->set_has_fetch_handler(true);
+  registration = RunRegisterJob(pattern, script);
+  version = registration->active_version();
+  EXPECT_TRUE(version->has_fetch_handler());
+
+  registration = FindRegistrationForPattern(pattern);

[falken, 2016/05/25 04:30:17]

I think FindRegistraitonForPattern will ultimately just return the live
registration, so you'll just get registration back again. I'd just simplify
these paragraphs to:

helper->set_has_fetch_handler(true);
RunRegisterJob(pattern, script);
registration = FindRegistrationForPattern(pattern);
EXPECT_TRUE(registration->active_version()->has_fetch_handler());
RunUnregisterJob(pattern)

helper->set_has_fetch_handler(false);
...

[shimazu, 2016/05/25 07:22:39]

Done.

+  version = registration->active_version();
+  EXPECT_TRUE(version->has_fetch_handler());
+  RunUnregisterJob(pattern);
+
+  helper->set_has_fetch_handler(false);
+  registration = RunRegisterJob(pattern, script);
+  version = registration->active_version();
+  EXPECT_FALSE(version->has_fetch_handler());
+
+  registration = FindRegistrationForPattern(pattern);
+  version = registration->active_version();
+  EXPECT_FALSE(version->has_fetch_handler());
+  RunUnregisterJob(pattern);
+}
+
 TEST_F(ServiceWorkerJobTest, Update_PauseAfterDownload) {
   UpdateJobTestHelper* update_helper = new UpdateJobTestHelper;
   helper_.reset(update_helper);
   IPC::TestSink* sink = update_helper->ipc_sink();
 
   // The initial version should not pause after download.
   scoped_refptr<ServiceWorkerRegistration> registration =
       update_helper->SetupInitialRegistration(kNewVersionOrigin);
   {
     const IPC::Message* start_msg =
@@ skipping 16 matching lines @@
     ASSERT_TRUE(start_msg);
     EmbeddedWorkerMsg_StartWorker::Param param;
     EmbeddedWorkerMsg_StartWorker::Read(start_msg, &param);
     EmbeddedWorkerMsg_StartWorker_Params start_params = base::get<0>(param);
     EXPECT_TRUE(start_params.pause_after_download);
     sink->ClearMessages();
   }
 }
 
 }  // namespace content