content/browser/service_worker/service_worker_provider_host_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/basictypes.h"
   6 #include "base/memory/weak_ptr.h"
   7 #include "base/thread_task_runner_handle.h"
   8 #include "content/browser/service_worker/service_worker_context_core.h"
   9 #include "content/browser/service_worker/service_worker_provider_host.h"
  10 #include "content/browser/service_worker/service_worker_register_job.h"
  11 #include "content/browser/service_worker/service_worker_registration.h"
  12 #include "content/browser/service_worker/service_worker_version.h"
  13 #include "content/public/test/test_browser_thread_bundle.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace content {
  17
  18 static const int kRenderProcessId = 33;  // Dummy process ID for testing.
  19
  20 class ServiceWorkerProviderHostTest : public testing::Test {
  21  protected:
  22   ServiceWorkerProviderHostTest()
  23       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
  24   virtual ~ServiceWorkerProviderHostTest() {}
  25
  26   virtual void SetUp() OVERRIDE {
  27     context_.reset(
  28         new ServiceWorkerContextCore(base::FilePath(),
  29                                      base::ThreadTaskRunnerHandle::Get(),
  30                                      base::ThreadTaskRunnerHandle::Get(),
  31                                      base::ThreadTaskRunnerHandle::Get(),
  32                                      NULL,
  33                                      NULL,
  34                                      NULL));
  35
  36     scope_ = GURL("http://www.example.com/");
  37     script_url_ = GURL("http://www.example.com/service_worker.js");
  38     registration_ = new ServiceWorkerRegistration(
  39         scope_, script_url_, 1L, context_->AsWeakPtr());
  40     version_ = new ServiceWorkerVersion(
  41         registration_.get(), 1L, context_->AsWeakPtr());
  42
  43     // Prepare provider hosts (for the same process).
  44     scoped_ptr<ServiceWorkerProviderHost> host1(new ServiceWorkerProviderHost(
  45         kRenderProcessId, 1 /* provider_id */,
  46         context_->AsWeakPtr(), NULL));
  47     scoped_ptr<ServiceWorkerProviderHost> host2(new ServiceWorkerProviderHost(
  48         kRenderProcessId, 2 /* provider_id */,
  49         context_->AsWeakPtr(), NULL));
  50     provider_host1_ = host1->AsWeakPtr();
  51     provider_host2_ = host2->AsWeakPtr();
  52     context_->AddProviderHost(make_scoped_ptr(host1.release()));
  53     context_->AddProviderHost(make_scoped_ptr(host2.release()));
  54   }
  55
  56   virtual void TearDown() OVERRIDE {
  57     version_ = 0;
  58     registration_ = 0;
  59     context_.reset();
  60   }
  61
  62   void VerifyVersionAttributes(
  63       base::WeakPtr<ServiceWorkerProviderHost> provider_host,
  64       ServiceWorkerVersion* installing,
  65       ServiceWorkerVersion* waiting,
  66       ServiceWorkerVersion* active) {
  67     EXPECT_EQ(installing, provider_host->installing_version_.get());
  68     EXPECT_EQ(waiting, provider_host->waiting_version_.get());
  69     EXPECT_EQ(active, provider_host->active_version_.get());
  70     EXPECT_FALSE(provider_host->controlling_version_.get());
  71   }
  72
  73   content::TestBrowserThreadBundle thread_bundle_;
  74   scoped_ptr<ServiceWorkerContextCore> context_;
  75   scoped_refptr<ServiceWorkerRegistration> registration_;
  76   scoped_refptr<ServiceWorkerVersion> version_;
  77   base::WeakPtr<ServiceWorkerProviderHost> provider_host1_;
  78   base::WeakPtr<ServiceWorkerProviderHost> provider_host2_;
  79   GURL scope_;
  80   GURL script_url_;
  81
  82  private:
  83   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerProviderHostTest);
  84 };
  85
  86 TEST_F(ServiceWorkerProviderHostTest, SetActiveVersion_ProcessStatus) {
  87   provider_host1_->AssociateRegistration(registration_.get());
  88   ASSERT_FALSE(version_->HasProcessToRun());
  89
  90   // Associating version_ to a provider_host's active version will internally
  91   // add the provider_host's process ref to the version.
  92   registration_->SetActiveVersion(version_.get());
  93   ASSERT_TRUE(version_->HasProcessToRun());
  94
  95   // Re-associating the same version and provider_host should just work too.
  96   registration_->SetActiveVersion(version_.get());
  97   ASSERT_TRUE(version_->HasProcessToRun());
  98
  99   // Resetting the provider_host's active version should remove process refs
 100   // from the version.
 101   provider_host1_->UnassociateRegistration();
 102   ASSERT_FALSE(version_->HasProcessToRun());
 103 }
 104
 105 TEST_F(ServiceWorkerProviderHostTest,
 106        SetActiveVersion_MultipleHostsForSameProcess) {
 107   provider_host1_->AssociateRegistration(registration_.get());
 108   provider_host2_->AssociateRegistration(registration_.get());
 109   ASSERT_FALSE(version_->HasProcessToRun());
 110
 111   // Associating version_ to two providers as active version.
 112   registration_->SetActiveVersion(version_.get());
 113   ASSERT_TRUE(version_->HasProcessToRun());
 114
 115   // Disassociating one provider_host shouldn't remove all process refs
 116   // from the version yet.
 117   provider_host1_->UnassociateRegistration();
 118   ASSERT_TRUE(version_->HasProcessToRun());
 119
 120   // Disassociating the other provider_host will remove all process refs.
 121   provider_host2_->UnassociateRegistration();
 122   ASSERT_FALSE(version_->HasProcessToRun());
 123 }
 124
 125 TEST_F(ServiceWorkerProviderHostTest, SetWaitingVersion_ProcessStatus) {
 126   provider_host1_->AssociateRegistration(registration_.get());
 127   ASSERT_FALSE(version_->HasProcessToRun());
 128
 129   // Associating version_ to a provider_host's waiting version will internally
 130   // add the provider_host's process ref to the version.
 131   registration_->SetWaitingVersion(version_.get());
 132   ASSERT_TRUE(version_->HasProcessToRun());
 133
 134   // Re-associating the same version and provider_host should just work too.
 135   registration_->SetWaitingVersion(version_.get());
 136   ASSERT_TRUE(version_->HasProcessToRun());
 137
 138   // Resetting the provider_host's waiting version should remove process refs
 139   // from the version.
 140   provider_host1_->UnassociateRegistration();
 141   ASSERT_FALSE(version_->HasProcessToRun());
 142 }
 143
 144 TEST_F(ServiceWorkerProviderHostTest,
 145        SetWaitingVersion_MultipleHostsForSameProcess) {
 146   provider_host1_->AssociateRegistration(registration_.get());
 147   provider_host2_->AssociateRegistration(registration_.get());
 148   ASSERT_FALSE(version_->HasProcessToRun());
 149
 150   // Associating version_ to two providers as waiting version.
 151   registration_->SetWaitingVersion(version_.get());
 152   ASSERT_TRUE(version_->HasProcessToRun());
 153
 154   // Disassociating one provider_host shouldn't remove all process refs
 155   // from the version yet.
 156   provider_host1_->UnassociateRegistration();
 157   ASSERT_TRUE(version_->HasProcessToRun());
 158
 159   // Disassociating the other provider_host will remove all process refs.
 160   provider_host2_->UnassociateRegistration();
 161   ASSERT_FALSE(version_->HasProcessToRun());
 162 }
 163
 164 TEST_F(ServiceWorkerProviderHostTest,
 165        ObserveVersionAttributesChanged_Basic) {
 166   provider_host1_->AssociateRegistration(registration_.get());
 167   provider_host2_->AssociateRegistration(registration_.get());
 168   VerifyVersionAttributes(provider_host1_, NULL, NULL, NULL);
 169   VerifyVersionAttributes(provider_host2_, NULL, NULL, NULL);
 170
 171   registration_->SetInstallingVersion(version_.get());
 172   VerifyVersionAttributes(provider_host1_, version_.get(), NULL, NULL);
 173   VerifyVersionAttributes(provider_host2_, version_.get(), NULL, NULL);
 174
 175   registration_->SetWaitingVersion(version_.get());
 176   VerifyVersionAttributes(provider_host1_, NULL, version_.get(), NULL);
 177   VerifyVersionAttributes(provider_host2_, NULL, version_.get(), NULL);
 178
 179   // Disassociating the registration should clear all version attributes.
 180   provider_host2_->UnassociateRegistration();
 181   VerifyVersionAttributes(provider_host1_, NULL, version_.get(), NULL);
 182   VerifyVersionAttributes(provider_host2_, NULL, NULL, NULL);
 183
 184   // Shouldn't notify the disassociated provider of the change.
 185   registration_->SetActiveVersion(version_.get());
 186   VerifyVersionAttributes(provider_host1_, NULL, NULL, version_.get());
 187   VerifyVersionAttributes(provider_host2_, NULL, NULL, NULL);
 188 }
 189
 190 TEST_F(ServiceWorkerProviderHostTest,
 191        ObserveVersionAttributesChanged_MultipleVersions) {
 192   provider_host1_->AssociateRegistration(registration_.get());
 193   provider_host2_->AssociateRegistration(registration_.get());
 194   VerifyVersionAttributes(provider_host1_, NULL, NULL, NULL);
 195   VerifyVersionAttributes(provider_host2_, NULL, NULL, NULL);
 196
 197   scoped_refptr<ServiceWorkerVersion> version1 =
 198       new ServiceWorkerVersion(registration_.get(), 10L, context_->AsWeakPtr());
 199   scoped_refptr<ServiceWorkerVersion> version2 =
 200       new ServiceWorkerVersion(registration_.get(), 20L, context_->AsWeakPtr());
 201
 202   registration_->SetInstallingVersion(version1.get());
 203   VerifyVersionAttributes(provider_host1_, version1.get(), NULL, NULL);
 204   VerifyVersionAttributes(provider_host2_, version1.get(), NULL, NULL);
 205
 206   registration_->SetWaitingVersion(version1.get());
 207   VerifyVersionAttributes(provider_host1_, NULL, version1.get(), NULL);
 208   VerifyVersionAttributes(provider_host2_, NULL, version1.get(), NULL);
 209
 210   registration_->SetInstallingVersion(version2.get());
 211   VerifyVersionAttributes(
 212       provider_host1_, version2.get(), version1.get(), NULL);
 213   VerifyVersionAttributes(
 214       provider_host2_, version2.get(), version1.get(), NULL);
 215
 216   // Disassociating the registration should clear all version attributes.
 217   provider_host2_->UnassociateRegistration();
 218   VerifyVersionAttributes(
 219       provider_host1_, version2.get(), version1.get(), NULL);
 220   VerifyVersionAttributes(provider_host2_, NULL, NULL, NULL);
 221
 222   // Shouldn't notify the disassociated provider of the change.
 223   registration_->SetActiveVersion(version1.get());
 224   VerifyVersionAttributes(
 225       provider_host1_, version2.get(), NULL, version1.get());
 226   VerifyVersionAttributes(provider_host2_, NULL, NULL, NULL);
 227
 228   registration_->SetActiveVersion(version2.get());
 229   VerifyVersionAttributes(provider_host1_, NULL, NULL, version2.get());
 230   VerifyVersionAttributes(provider_host2_, NULL, NULL, NULL);
 231 }
 232
 233 }  // namespace content