ServiceWorker: Confirm the liveness of the associated context before handling message

content/browser/service_worker/service_worker_dispatcher_host_unittest.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_dispatcher_host.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/run_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
+#include "content/browser/service_worker/service_worker_provider_host_registry.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 static const int kRenderProcessId = 1;
 
 class ServiceWorkerDispatcherHostTest : public testing::Test {
  protected:
   ServiceWorkerDispatcherHostTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
 
   virtual void SetUp() {
     helper_.reset(new EmbeddedWorkerTestHelper(kRenderProcessId));
   }
 
   virtual void TearDown() {
     helper_.reset();
   }
 
-  ServiceWorkerContextCore* context() { return helper_->context(); }
   ServiceWorkerContextWrapper* context_wrapper() {
     return helper_->context_wrapper();
   }
 
+  ServiceWorkerProviderHostRegistry* provider_registry() {
+    return context_wrapper()->provider_registry();
+  }
+
   TestBrowserThreadBundle browser_thread_bundle_;
   scoped_ptr<EmbeddedWorkerTestHelper> helper_;
 };
 
 
 class TestingServiceWorkerDispatcherHost : public ServiceWorkerDispatcherHost {
  public:
   TestingServiceWorkerDispatcherHost(
       int process_id,
       ServiceWorkerContextWrapper* context_wrapper,
@@ skipping 91 matching lines @@
 
 TEST_F(ServiceWorkerDispatcherHostTest, ProviderCreatedAndDestroyed) {
   scoped_refptr<TestingServiceWorkerDispatcherHost> dispatcher_host =
       new TestingServiceWorkerDispatcherHost(
           kRenderProcessId, context_wrapper(), helper_.get());
 
   const int kProviderId = 1001;  // Test with a value != kRenderProcessId.
 
   dispatcher_host->OnMessageReceived(
       ServiceWorkerHostMsg_ProviderCreated(kProviderId));
-  EXPECT_TRUE(context()->GetProviderHost(kRenderProcessId, kProviderId));
+  EXPECT_TRUE(provider_registry()->GetProviderHost(kRenderProcessId,
+                                                   kProviderId));
 
   // Two with the same ID should be seen as a bad message.
   dispatcher_host->OnMessageReceived(
       ServiceWorkerHostMsg_ProviderCreated(kProviderId));
   EXPECT_EQ(1, dispatcher_host->bad_messages_received_count_);
 
   dispatcher_host->OnMessageReceived(
       ServiceWorkerHostMsg_ProviderDestroyed(kProviderId));
-  EXPECT_FALSE(context()->GetProviderHost(kRenderProcessId, kProviderId));
+  EXPECT_FALSE(provider_registry()->GetProviderHost(kRenderProcessId,
+                                                    kProviderId));
 
   // Destroying an ID that does not exist warrants a bad message.
   dispatcher_host->OnMessageReceived(
       ServiceWorkerHostMsg_ProviderDestroyed(kProviderId));
   EXPECT_EQ(2, dispatcher_host->bad_messages_received_count_);
 
   // Deletion of the dispatcher_host should cause providers for that
   // process to get deleted as well.
   dispatcher_host->OnMessageReceived(
       ServiceWorkerHostMsg_ProviderCreated(kProviderId));
-  EXPECT_TRUE(context()->GetProviderHost(kRenderProcessId, kProviderId));
+  EXPECT_TRUE(provider_registry()->GetProviderHost(kRenderProcessId,
+                                                   kProviderId));
   EXPECT_TRUE(dispatcher_host->HasOneRef());
   dispatcher_host = NULL;
-  EXPECT_FALSE(context()->GetProviderHost(kRenderProcessId, kProviderId));
+  EXPECT_FALSE(provider_registry()->GetProviderHost(kRenderProcessId,
+                                                    kProviderId));
 }
 
 }  // namespace content