Add browser test for V8 code caching for ServiceWorker scripts.

content/browser/service_worker/service_worker_browsertest.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 "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
@@ skipping 257 matching lines @@
 
   ServiceWorkerVersion* version =
       wrapper->context()->GetLiveVersion(version_id);
   *num_resources = static_cast<int>(version->script_cache_map()->size());
 }
 
 }  // namespace
 
 class ServiceWorkerBrowserTest : public ContentBrowserTest {
  protected:
-  typedef ServiceWorkerBrowserTest self;
+  using self = ServiceWorkerBrowserTest;
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(
         switches::kEnableExperimentalWebPlatformFeatures);
   }
 
   void SetUpOnMainThread() override {
     ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
     StoragePartition* partition = BrowserContext::GetDefaultStoragePartition(
         shell()->web_contents()->GetBrowserContext());
@@ skipping 25 matching lines @@
         pattern, shell()->web_contents()->GetRenderProcessHost()->GetID());
   }
 
  private:
   scoped_refptr<ServiceWorkerContextWrapper> wrapper_;
 };
 
 class EmbeddedWorkerBrowserTest : public ServiceWorkerBrowserTest,
                                   public EmbeddedWorkerInstance::Listener {
  public:
-  typedef EmbeddedWorkerBrowserTest self;
+  using self = EmbeddedWorkerBrowserTest;
 
   EmbeddedWorkerBrowserTest()
       : last_worker_status_(EmbeddedWorkerInstance::STOPPED),
         pause_mode_(DONT_PAUSE) {}
   ~EmbeddedWorkerBrowserTest() override {}
 
   void TearDownOnIOThread() override {
     if (worker_) {
       worker_->RemoveListener(this);
       worker_.reset();
     }
   }
 
   void StartOnIOThread() {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     worker_ = wrapper()->context()->embedded_worker_registry()->CreateWorker();
     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(
         "/service_worker/worker.js");
     AssociateRendererProcessToPattern(pattern);
     int process_id = shell()->web_contents()->GetRenderProcessHost()->GetID();
     wrapper()->process_manager()->AddProcessReferenceToPattern(
         pattern, process_id);
     worker_->Start(
         service_worker_version_id,
@@ skipping 67 matching lines @@
     PAUSE_THEN_STOP,
   } pause_mode_;
 
   // Called by EmbeddedWorkerInstance::Observer overrides so that
   // test code can wait for the worker status notifications.
   base::Closure done_closure_;
 };
 
 class ServiceWorkerVersionBrowserTest : public ServiceWorkerBrowserTest {
  public:
-  typedef ServiceWorkerVersionBrowserTest self;
+  using self = ServiceWorkerVersionBrowserTest;
 
   ~ServiceWorkerVersionBrowserTest() override {}
 
   void TearDownOnIOThread() override {
     registration_ = NULL;
     version_ = NULL;
   }
 
   void InstallTestHelper(const std::string& worker_url,
                          ServiceWorkerStatusCode expected_status) {
@@ skipping 84 matching lines @@
         wrapper()->context()->AsWeakPtr());
     AssociateRendererProcessToPattern(pattern);
   }
 
   void TimeoutWorkerOnIOThread() {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->PingWorker();
     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));
     version_->StartWorker(CreateReceiver(BrowserThread::UI, done, result));
   }
 
   void InstallOnIOThread(const base::Closure& done,
                          ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->SetStatus(ServiceWorkerVersion::INSTALLING);
@@ skipping 111 matching lines @@
                                      &status));
   stop_run_loop.Run();
   ASSERT_EQ(SERVICE_WORKER_OK, status);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, StartNotFound) {
   RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread, this,
                            "/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) {
   InstallTestHelper("/service_worker/worker.js", SERVICE_WORKER_OK);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                        InstallWithWaitUntil_Fulfilled) {
   InstallTestHelper("/service_worker/worker_install_fulfilled.js",
                     SERVICE_WORKER_OK);
@@ skipping 291 matching lines @@
   RunOnIOThread(
       base::Bind(&CountScriptResources,
                  base::Unretained(wrapper()),
                  embedded_test_server()->GetURL(kScopeUrl),
                  &num_resources));
   EXPECT_EQ(kExpectedNumResources, num_resources);
 }
 
 class ServiceWorkerBlackBoxBrowserTest : public ServiceWorkerBrowserTest {
  public:
-  typedef ServiceWorkerBlackBoxBrowserTest self;
+  using self = ServiceWorkerBlackBoxBrowserTest;
 
   void FindRegistrationOnIO(const GURL& document_url,
                             ServiceWorkerStatusCode* status,
                             const base::Closure& continuation) {
     wrapper()->context()->storage()->FindRegistrationForDocument(
         document_url,
         base::Bind(&ServiceWorkerBlackBoxBrowserTest::FindRegistrationOnIO2,
                    this,
                    status,
                    continuation));
@@ skipping 125 matching lines @@
       "cross_site_xfer_confirm_via_serviceworker.html";
   const base::string16 kOKTitle2(base::ASCIIToUTF16("OK_2"));
   const base::string16 kFailTitle2(base::ASCIIToUTF16("FAIL_2"));
   content::TitleWatcher title_watcher2(shell()->web_contents(), kOKTitle2);
   title_watcher2.AlsoWaitForTitle(kFailTitle2);
 
   NavigateToURL(shell(), embedded_test_server()->GetURL(kConfirmPageUrl));
   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