ServiceWorker: Enable UseCounter for ServiceWorkerGlobalScope

content/browser/service_worker/service_worker_storage_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_storage.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 
@@ skipping 655 matching lines @@
   scoped_refptr<ServiceWorkerVersion> live_version = new ServiceWorkerVersion(
       live_registration.get(), kResource1, kVersionId, context()->AsWeakPtr());
   live_version->set_fetch_handler_existence(
       ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
   live_version->SetStatus(ServiceWorkerVersion::INSTALLED);
   live_version->script_cache_map()->SetResources(resources);
   live_version->set_foreign_fetch_scopes(
       std::vector<GURL>(1, kForeignFetchScope));
   live_version->set_foreign_fetch_origins(
       std::vector<url::Origin>(1, kForeignFetchOrigin));
+  live_version->set_used_features({124, 901, 1019});
   live_registration->SetWaitingVersion(live_version);
   live_registration->set_last_update_check(kYesterday);
   EXPECT_EQ(SERVICE_WORKER_OK,
             StoreRegistration(live_registration, live_version));
 
   // Now we should find it and get the live ptr back immediately.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   EXPECT_EQ(kResource1Size + kResource2Size,
@@ skipping 77 matching lines @@
   EXPECT_EQ(ServiceWorkerVersion::INSTALLED,
             found_registration->waiting_version()->status());
   EXPECT_EQ(
       1u, found_registration->waiting_version()->foreign_fetch_scopes().size());
   EXPECT_EQ(kForeignFetchScope,
             found_registration->waiting_version()->foreign_fetch_scopes()[0]);
   EXPECT_EQ(
       1u,
       found_registration->waiting_version()->foreign_fetch_origins().size());
   EXPECT_EQ(kForeignFetchOrigin,
             found_registration->waiting_version()->foreign_fetch_origins()[0]);

[falken, 2017/02/08 05:01:53]

Should we check the used features somewhere in this test?

[nhiroki, 2017/02/09 05:11:31]

Yeah, I should have checked it. Done.

 
   // Update to active and update the last check time.
   scoped_refptr<ServiceWorkerVersion> temp_version =
       found_registration->waiting_version();
   temp_version->SetStatus(ServiceWorkerVersion::ACTIVATED);
   found_registration->SetActiveVersion(temp_version);
   temp_version = NULL;
   EXPECT_EQ(SERVICE_WORKER_OK, UpdateToActiveState(found_registration));
   found_registration->set_last_update_check(kToday);
   UpdateLastUpdateCheckTime(found_registration.get());
@@ skipping 355 matching lines @@
     resource_id1_size_ = 239193;
     resource_id2_size_ = 59923;
 
     // Cons up a new registration+version with two script resources.
     RegistrationData data;
     data.registration_id = registration_id_;
     data.scope = scope_;
     data.script = script_;
     data.version_id = version_id_;
     data.is_active = false;
+    data.used_features = {109, 421, 9101};
     std::vector<ResourceRecord> resources;
     resources.push_back(
         ResourceRecord(resource_id1_, script_, resource_id1_size_));
     resources.push_back(
         ResourceRecord(resource_id2_, import_, resource_id2_size_));
     registration_ = storage()->GetOrCreateRegistration(data, resources);
     registration_->waiting_version()->SetStatus(ServiceWorkerVersion::NEW);
 
     // Add the resources ids to the uncommitted list.
     storage()->StoreUncommittedResourceId(resource_id1_);
@@ skipping 411 matching lines @@
       registration_.get(), script_, storage()->NewVersionId(),
       context()->AsWeakPtr());
   live_version->SetStatus(ServiceWorkerVersion::NEW);
   registration_->SetWaitingVersion(live_version);
   std::vector<ServiceWorkerDatabase::ResourceRecord> records;
   records.push_back(ServiceWorkerDatabase::ResourceRecord(
       10, live_version->script_url(), 100));
   live_version->script_cache_map()->SetResources(records);
   live_version->set_fetch_handler_existence(
       ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
+  live_version->set_used_features({124, 901, 1019});

[falken, 2017/02/08 05:01:53]

Just curious why we set the used features here. Should it be checked later?

[nhiroki, 2017/02/09 05:11:31]

Yeah, this doesn't really make sense. I meant to check whether a new version
overrides an incumbent version in terms of used_features, but it's obvious
because used_features is owned by SWVersion and replacement of SWVersion is
well-tested in other unittests and layouttests, so I removed this.

 
   // Writing the registration should move the old version's resources to the
   // purgeable list but keep them available.
   storage()->StoreRegistration(
       registration_.get(),
       registration_->waiting_version(),
       base::Bind(&VerifyPurgeableListStatusCallback,
                  base::Unretained(storage()->database_.get()),
                  &verify_ids,
                  &was_called,
                  &result));
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(was_called);
   EXPECT_EQ(SERVICE_WORKER_OK, result);
   EXPECT_EQ(2u, verify_ids.size());
   verify_ids.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             storage()->database_->GetPurgeableResourceIds(&verify_ids));
   EXPECT_EQ(2u, verify_ids.size());
 
   EXPECT_TRUE(VerifyBasicResponse(storage(), resource_id1_, false));
   EXPECT_TRUE(VerifyBasicResponse(storage(), resource_id2_, false));
 
+  scoped_refptr<ServiceWorkerRegistration> found_registration;
+  EXPECT_EQ(SERVICE_WORKER_OK,
+            FindRegistrationForDocument(document_url_, &found_registration));
+  EXPECT_EQ(registration_, found_registration);
+
   // Removing the controllee should cause the old version's resources to be
   // deleted.
   registration_->active_version()->RemoveControllee(host.get());
   registration_->active_version()->Doom();
   base::RunLoop().RunUntilIdle();
   verify_ids.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             storage()->database_->GetPurgeableResourceIds(&verify_ids));
   EXPECT_TRUE(verify_ids.empty());
 
@@ skipping 515 matching lines @@
   EXPECT_TRUE(registration_state.enabled);
   EXPECT_EQ(kHeaderValue, registration_state.header);
   ASSERT_TRUE(found_registration->active_version());
   const NavigationPreloadState& state =
       found_registration->active_version()->navigation_preload_state();
   EXPECT_TRUE(state.enabled);
   EXPECT_EQ(kHeaderValue, state.header);
 }
 
 }  // namespace content