Add browser test for V8 code caching for ServiceWorker scripts.

BUG=449895
TEST=content_browsertests --gtest_filter=ServiceWorkerVersionBrowserV8CacheTest.*

Review URL: https://codereview.chromium.org/945413005

Cr-Commit-Position: refs/heads/master@{#317762}

content/browser/service_worker/service_worker_browsertest.cc

@@ -275,7 +275,7 @@ void CountScriptResources(
 
 class ServiceWorkerBrowserTest : public ContentBrowserTest {
  protected:
-  typedef ServiceWorkerBrowserTest self;
+  using self = ServiceWorkerBrowserTest;
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(
@@ -321,7 +321,7 @@ class ServiceWorkerBrowserTest : public ContentBrowserTest {
 class EmbeddedWorkerBrowserTest : public ServiceWorkerBrowserTest,
                                   public EmbeddedWorkerInstance::Listener {
  public:
-  typedef EmbeddedWorkerBrowserTest self;
+  using self = EmbeddedWorkerBrowserTest;
 
   EmbeddedWorkerBrowserTest()
       : last_worker_status_(EmbeddedWorkerInstance::STOPPED),
@@ -341,7 +341,6 @@ class EmbeddedWorkerBrowserTest : public ServiceWorkerBrowserTest,
     EXPECT_EQ(EmbeddedWorkerInstance::STOPPED, worker_->status());
     worker_->AddListener(this);
 
-
     const int64 service_worker_version_id = 33L;
     const GURL pattern = embedded_test_server()->GetURL("/");
     const GURL script_url = embedded_test_server()->GetURL(
@@ -429,7 +428,7 @@ class EmbeddedWorkerBrowserTest : public ServiceWorkerBrowserTest,
 
 class ServiceWorkerVersionBrowserTest : public ServiceWorkerBrowserTest {
  public:
-  typedef ServiceWorkerVersionBrowserTest self;
+  using self = ServiceWorkerVersionBrowserTest;
 
   ~ServiceWorkerVersionBrowserTest() override {}
 
@@ -534,6 +533,30 @@ class ServiceWorkerVersionBrowserTest : public ServiceWorkerBrowserTest {
     version_->OnPingTimeout();
   }
 
+  void StartWorker(ServiceWorkerStatusCode expected_status) {
+    ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
+    base::RunLoop start_run_loop;
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(&self::StartOnIOThread, this,
+                                       start_run_loop.QuitClosure(),
+                                       &status));
+    start_run_loop.Run();
+    ASSERT_EQ(expected_status, status);
+  }
+
+  void StopWorker(ServiceWorkerStatusCode expected_status) {
+    ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
+    base::RunLoop stop_run_loop;
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(&self::StopOnIOThread, this,
+                                       stop_run_loop.QuitClosure(),
+                                       &status));
+    stop_run_loop.Run();
+    ASSERT_EQ(expected_status, status);
+  }
+
   void StartOnIOThread(const base::Closure& done,
                        ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ -665,14 +688,7 @@ IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, StartNotFound) {
                            "/service_worker/nonexistent.js"));
 
   // Start a worker for nonexistent URL.
-  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
-  base::RunLoop start_run_loop;
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&self::StartOnIOThread, this,
-                                     start_run_loop.QuitClosure(),
-                                     &status));
-  start_run_loop.Run();
-  ASSERT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, status);
+  StartWorker(SERVICE_WORKER_ERROR_START_WORKER_FAILED);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, Install) {
@@ -984,7 +1000,7 @@ IN_PROC_BROWSER_TEST_F(ServiceWorkerBrowserTest, ImportsBustMemcache) {
 
 class ServiceWorkerBlackBoxBrowserTest : public ServiceWorkerBrowserTest {
  public:
-  typedef ServiceWorkerBlackBoxBrowserTest self;
+  using self = ServiceWorkerBlackBoxBrowserTest;
 
   void FindRegistrationOnIO(const GURL& document_url,
                             ServiceWorkerStatusCode* status,
@@ -1130,4 +1146,62 @@ IN_PROC_BROWSER_TEST_F(ServiceWorkerBrowserTest, CrossSiteTransfer) {
   EXPECT_EQ(kOKTitle2, title_watcher2.WaitAndGetTitle());
 }
 
+class ServiceWorkerVersionBrowserV8CacheTest
+    : public ServiceWorkerVersionBrowserTest,
+      public ServiceWorkerVersion::Listener {
+ public:
+  using self = ServiceWorkerVersionBrowserV8CacheTest;
+  ~ServiceWorkerVersionBrowserV8CacheTest() override {
+    if (version_)
+      version_->RemoveListener(this);
+  }
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    ServiceWorkerBrowserTest::SetUpCommandLine(command_line);
+    command_line->AppendSwitchASCII(switches::kV8CacheOptions, "code");
+  }
+  void SetUpRegistrationAndListenerOnIOThread(const std::string& worker_url) {
+    SetUpRegistrationOnIOThread(worker_url);
+    version_->AddListener(this);
+  }
+
+ protected:
+  // ServiceWorkerVersion::Listener overrides
+  void OnCachedMetadataUpdated(ServiceWorkerVersion* version) override {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            cache_updated_closure_);
+  }
+
+  base::Closure cache_updated_closure_;
+};
+
+IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserV8CacheTest, Restart) {
+  RunOnIOThread(base::Bind(&self::SetUpRegistrationAndListenerOnIOThread, this,
+                           "/service_worker/worker.js"));
+
+  base::RunLoop cached_metadata_run_loop;
+  cache_updated_closure_ = cached_metadata_run_loop.QuitClosure();
+
+  // Start a worker.
+  StartWorker(SERVICE_WORKER_OK);
+
+  // Wait for the matadata is stored. This run loop should finish when
+  // OnCachedMetadataUpdated() is called.
+  cached_metadata_run_loop.Run();
+
+  // Activate the worker.
+  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
+  base::RunLoop acrivate_run_loop;
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&self::ActivateOnIOThread, this,
+                                     acrivate_run_loop.QuitClosure(), &status));
+  acrivate_run_loop.Run();
+  ASSERT_EQ(SERVICE_WORKER_OK, status);
+  // Stop the worker.
+  StopWorker(SERVICE_WORKER_OK);
+  // Restart the worker.
+  StartWorker(SERVICE_WORKER_OK);
+  // Stop the worker.
+  StopWorker(SERVICE_WORKER_OK);
+}
+
 }  // namespace content

content/browser/service_worker/service_worker_version.cc

@@ -278,18 +278,6 @@ void KillEmbeddedWorkerProcess(int process_id, ResultCode code) {
     render_process_host->ReceivedBadMessage();
 }
 
-void DidSetCachedMetadata(int64 callback_id, int result) {
-  TRACE_EVENT_ASYNC_END1("ServiceWorker",
-                         "ServiceWorkerVersion::OnSetCachedMetadata",
-                         callback_id, "result", result);
-}
-
-void DidClearCachedMetadata(int64 callback_id, int result) {
-  TRACE_EVENT_ASYNC_END1("ServiceWorker",
-                         "ServiceWorkerVersion::OnClearCachedMetadata",
-                         callback_id, "result", result);
-}
-
 }  // namespace
 
 ServiceWorkerVersion::ServiceWorkerVersion(
@@ -1264,7 +1252,16 @@ void ServiceWorkerVersion::OnSetCachedMetadata(const GURL& url,
                            "ServiceWorkerVersion::OnSetCachedMetadata",
                            callback_id, "URL", url.spec());
   script_cache_map_.WriteMetadata(
-      url, data, base::Bind(&DidSetCachedMetadata, callback_id));
+      url, data, base::Bind(&ServiceWorkerVersion::OnSetCachedMetadataFinished,
+                            weak_factory_.GetWeakPtr(), callback_id));
+}
+
+void ServiceWorkerVersion::OnSetCachedMetadataFinished(int64 callback_id,
+                                                       int result) {
+  TRACE_EVENT_ASYNC_END1("ServiceWorker",
+                         "ServiceWorkerVersion::OnSetCachedMetadata",
+                         callback_id, "result", result);
+  FOR_EACH_OBSERVER(Listener, listeners_, OnCachedMetadataUpdated(this));
 }
 
 void ServiceWorkerVersion::OnClearCachedMetadata(const GURL& url) {
@@ -1273,7 +1270,16 @@ void ServiceWorkerVersion::OnClearCachedMetadata(const GURL& url) {
                            "ServiceWorkerVersion::OnClearCachedMetadata",
                            callback_id, "URL", url.spec());
   script_cache_map_.ClearMetadata(
-      url, base::Bind(&DidClearCachedMetadata, callback_id));
+      url, base::Bind(&ServiceWorkerVersion::OnClearCachedMetadataFinished,
+                      weak_factory_.GetWeakPtr(), callback_id));
+}
+
+void ServiceWorkerVersion::OnClearCachedMetadataFinished(int64 callback_id,
+                                                         int result) {
+  TRACE_EVENT_ASYNC_END1("ServiceWorker",
+                         "ServiceWorkerVersion::OnClearCachedMetadata",
+                         callback_id, "result", result);
+  FOR_EACH_OBSERVER(Listener, listeners_, OnCachedMetadataUpdated(this));
 }
 
 void ServiceWorkerVersion::OnPostMessageToDocument(

content/browser/service_worker/service_worker_version.h

@@ -109,6 +109,7 @@ class CONTENT_EXPORT ServiceWorkerVersion
                                         const GURL& source_url) {}
     // Fires when a version transitions from having a controllee to not.
     virtual void OnNoControllees(ServiceWorkerVersion* version) {}
+    virtual void OnCachedMetadataUpdated(ServiceWorkerVersion* version) {}
 
    protected:
     virtual ~Listener() {}
@@ -379,7 +380,9 @@ class CONTENT_EXPORT ServiceWorkerVersion
                             const ServiceWorkerClientInfo& client_info);
 
   void OnSetCachedMetadata(const GURL& url, const std::vector<char>& data);
+  void OnSetCachedMetadataFinished(int64 callback_id, int result);
   void OnClearCachedMetadata(const GURL& url);
+  void OnClearCachedMetadataFinished(int64 callback_id, int result);
 
   void OnPostMessageToDocument(int client_id,
                                const base::string16& message,

content/public/common/content_switches.h

@@ -237,7 +237,7 @@ CONTENT_EXPORT extern const char kUtilityProcess[];
 extern const char kUtilityProcessAllowedDir[];
 CONTENT_EXPORT extern const char kUtilityProcessEnableMDns[];
 CONTENT_EXPORT extern const char kUtilityProcessRunningElevated[];
-extern const char kV8CacheOptions[];
+CONTENT_EXPORT extern const char kV8CacheOptions[];
 CONTENT_EXPORT extern const char kValidateInputEventStream[];
 CONTENT_EXPORT extern const char kWaitForDebuggerChildren[];
 CONTENT_EXPORT extern const char kZygoteCmdPrefix[];