More scaffolding, add class ServiceWorkerProviderHost.

content/browser/service_worker/service_worker_dispatcher_host_unittest.cc

 // Copyright (c) 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/message_loop/message_loop.h"
+#include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
+#include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/common/service_worker_messages.h"
 #include "content/public/common/content_switches.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::MessageLoop;
 
 namespace content {
 
 class ServiceWorkerDispatcherHostTest : public testing::Test {
  protected:
+  ServiceWorkerDispatcherHostTest()
+      : io_thread_(BrowserThread::IO, &message_loop_) {}
+
   virtual void SetUp() {
-    context_.reset(new ServiceWorkerContextCore(base::FilePath(), NULL));
+    context_wrapper_ = new ServiceWorkerContextWrapper;
+    context_wrapper_->Init(base::FilePath(), NULL);
   }
 
   virtual void TearDown() {
-    context_.reset();
+    if (context_wrapper_) {
+      context_wrapper_->Shutdown();
+      context_wrapper_ = NULL;
+    }
   }
 
-  scoped_ptr<ServiceWorkerContextCore> context_;
+  ServiceWorkerContextCore* context() { return context_wrapper_->context(); }
+
+  scoped_refptr<ServiceWorkerContextWrapper> context_wrapper_;
+  base::MessageLoopForIO message_loop_;
+  BrowserThreadImpl io_thread_;
 };
 
 static const int kRenderProcessId = 1;
 
 class TestingServiceWorkerDispatcherHost : public ServiceWorkerDispatcherHost {
  public:
-  TestingServiceWorkerDispatcherHost(int process_id,
-                                     ServiceWorkerContextCore* context)
-      : ServiceWorkerDispatcherHost(process_id) {
-    context_ = context->AsWeakPtr();
+  TestingServiceWorkerDispatcherHost(
+      int process_id,
+      ServiceWorkerContextWrapper* context_wrapper)
+      : ServiceWorkerDispatcherHost(process_id),
+        bad_messages_received_count_(0) {
+    Init(context_wrapper);
   }
 
   virtual bool Send(IPC::Message* message) OVERRIDE {
     sent_messages_.push_back(message);
     return true;
   }
 
+  virtual void BadMessageReceived() OVERRIDE {
+    ++bad_messages_received_count_;
+  }
+
   ScopedVector<IPC::Message> sent_messages_;
+  int bad_messages_received_count_;
 
  protected:
   virtual ~TestingServiceWorkerDispatcherHost() {}
 };
 
 TEST_F(ServiceWorkerDispatcherHostTest, DisabledCausesError) {
   DCHECK(!CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kEnableServiceWorker));
 
   scoped_refptr<TestingServiceWorkerDispatcherHost> dispatcher_host =
-      new TestingServiceWorkerDispatcherHost(kRenderProcessId, context_.get());
+      new TestingServiceWorkerDispatcherHost(kRenderProcessId,
+                                             context_wrapper_.get());
 
   bool handled;
   dispatcher_host->OnMessageReceived(
       ServiceWorkerHostMsg_RegisterServiceWorker(-1, -1, GURL(), GURL()),
       &handled);
-  DCHECK(handled);
+  EXPECT_TRUE(handled);
 
   // TODO(alecflett): Pump the message loop when this becomes async.
-  DCHECK_EQ(1UL, dispatcher_host->sent_messages_.size());
-  DCHECK_EQ(
+  EXPECT_EQ(1UL, dispatcher_host->sent_messages_.size());

[kinuko, 2013/11/18 05:57:24]

nit: ASSERT_EQ may be better to avoid crash in line 89

[michaeln, 2013/11/18 20:18:17]

done

i'm really not sure what the best practice is here? anticipating what unmet
expectations will lead to a crash and treating them as assertions seems hard to
get right?

+  EXPECT_EQ(
       static_cast<uint32>(ServiceWorkerMsg_ServiceWorkerRegistrationError::ID),
       dispatcher_host->sent_messages_[0]->type());
 }
 
 TEST_F(ServiceWorkerDispatcherHostTest, Enabled) {
   DCHECK(!CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kEnableServiceWorker));
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableServiceWorker);
 
   scoped_refptr<TestingServiceWorkerDispatcherHost> dispatcher_host =
-      new TestingServiceWorkerDispatcherHost(kRenderProcessId, context_.get());
+      new TestingServiceWorkerDispatcherHost(kRenderProcessId,
+                                             context_wrapper_.get());
 
   bool handled;
   dispatcher_host->OnMessageReceived(
       ServiceWorkerHostMsg_RegisterServiceWorker(-1, -1, GURL(), GURL()),
       &handled);
-  DCHECK(handled);
+  EXPECT_TRUE(handled);
 
   // TODO(alecflett): Pump the message loop when this becomes async.
-  DCHECK_EQ(1UL, dispatcher_host->sent_messages_.size());
-  DCHECK_EQ(static_cast<uint32>(ServiceWorkerMsg_ServiceWorkerRegistered::ID),
+  EXPECT_EQ(1UL, dispatcher_host->sent_messages_.size());

[kinuko, 2013/11/18 05:57:24]

ditto

+  EXPECT_EQ(static_cast<uint32>(ServiceWorkerMsg_ServiceWorkerRegistered::ID),
             dispatcher_host->sent_messages_[0]->type());
 }
 
 TEST_F(ServiceWorkerDispatcherHostTest, EarlyContextDeletion) {
   DCHECK(!CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kEnableServiceWorker));
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableServiceWorker);
 
   scoped_refptr<TestingServiceWorkerDispatcherHost> dispatcher_host =
-      new TestingServiceWorkerDispatcherHost(kRenderProcessId, context_.get());
+      new TestingServiceWorkerDispatcherHost(kRenderProcessId,
+                                             context_wrapper_.get());
 
-  context_.reset();
+  context_wrapper_->Shutdown();
+  context_wrapper_ = NULL;
 
   bool handled;
   dispatcher_host->OnMessageReceived(
       ServiceWorkerHostMsg_RegisterServiceWorker(-1, -1, GURL(), GURL()),
       &handled);
-  DCHECK(handled);
+  EXPECT_TRUE(handled);
 
   // TODO(alecflett): Pump the message loop when this becomes async.
-  DCHECK_EQ(1UL, dispatcher_host->sent_messages_.size());
-  DCHECK_EQ(
+  EXPECT_EQ(1UL, dispatcher_host->sent_messages_.size());
+  EXPECT_EQ(
       static_cast<uint32>(ServiceWorkerMsg_ServiceWorkerRegistrationError::ID),
       dispatcher_host->sent_messages_[0]->type());
 }
 
+TEST_F(ServiceWorkerDispatcherHostTest, ProviderCreatedAndDestroyed) {
+  scoped_refptr<TestingServiceWorkerDispatcherHost> dispatcher_host =
+      new TestingServiceWorkerDispatcherHost(kRenderProcessId,
+                                             context_wrapper_.get());
+
+  bool handled = false;
+  dispatcher_host->OnMessageReceived(
+      ServiceWorkerHostMsg_ProviderCreated(1),
+      &handled);
+  EXPECT_TRUE(handled);
+  EXPECT_TRUE(context()->GetProviderHost(kRenderProcessId, 1));
+
+  handled = false;
+  dispatcher_host->OnMessageReceived(
+      ServiceWorkerHostMsg_ProviderCreated(1),
+      &handled);
+  EXPECT_TRUE(handled);
+  EXPECT_EQ(1, dispatcher_host->bad_messages_received_count_);
+
+  handled = false;
+  dispatcher_host->OnMessageReceived(
+      ServiceWorkerHostMsg_ProviderDestroyed(1),
+      &handled);
+  EXPECT_TRUE(handled);
+  EXPECT_FALSE(context()->GetProviderHost(kRenderProcessId, 1));
+
+  handled = false;
+  dispatcher_host->OnMessageReceived(
+      ServiceWorkerHostMsg_ProviderDestroyed(1),
+      &handled);
+  EXPECT_TRUE(handled);
+  EXPECT_EQ(2, dispatcher_host->bad_messages_received_count_);
+}
+
 }  // namespace content