ServiceWorker: Rename 'pending version' to 'installing' or 'waiting'

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 "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_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_disk_cache.h"
@@ skipping 213 matching lines @@
   was_called = false;
 
   // Store something.
   scoped_refptr<ServiceWorkerRegistration> live_registration =
       new ServiceWorkerRegistration(
           kScope, kScript, kRegistrationId, context_ptr_);
   scoped_refptr<ServiceWorkerVersion> live_version =
       new ServiceWorkerVersion(
           live_registration, kVersionId, context_ptr_);
   live_version->SetStatus(ServiceWorkerVersion::INSTALLED);
-  live_registration->set_pending_version(live_version);
+  live_registration->set_waiting_version(live_version);
   storage()->StoreRegistration(live_registration, live_version,
                                MakeStatusCallback(&was_called, &result));
   EXPECT_FALSE(was_called);  // always async
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(was_called);
   EXPECT_EQ(SERVICE_WORKER_OK, result);
   was_called = false;
 
   // Now we should find it and get the live ptr back immediately.
   storage()->FindRegistrationForDocument(
@@ skipping 40 matching lines @@
       kDocumentUrl,
       MakeFindCallback(&was_called, &result, &found_registration));
   EXPECT_FALSE(was_called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(was_called);
   EXPECT_EQ(SERVICE_WORKER_OK, result);
   ASSERT_TRUE(found_registration);
   EXPECT_EQ(kRegistrationId, found_registration->id());
   EXPECT_TRUE(found_registration->HasOneRef());
   EXPECT_EQ(live_version,
-            found_registration->pending_version());
+            found_registration->waiting_version());
   was_called = false;
   found_registration = NULL;
 
   // Drop the live version too.
   live_version = NULL;
 
   // And FindRegistrationForPattern is always async.
   storage()->FindRegistrationForPattern(
       kScope,
       MakeFindCallback(&was_called, &result, &found_registration));
   EXPECT_FALSE(was_called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(was_called);
   EXPECT_EQ(SERVICE_WORKER_OK, result);
   ASSERT_TRUE(found_registration);
   EXPECT_EQ(kRegistrationId, found_registration->id());
   EXPECT_TRUE(found_registration->HasOneRef());
   EXPECT_FALSE(found_registration->active_version());
-  ASSERT_TRUE(found_registration->pending_version());
+  ASSERT_TRUE(found_registration->waiting_version());
   EXPECT_EQ(ServiceWorkerVersion::INSTALLED,
-            found_registration->pending_version()->status());
+            found_registration->waiting_version()->status());
   was_called = false;
 
   // Update to active.
   scoped_refptr<ServiceWorkerVersion> temp_version =
-      found_registration->pending_version();
-  found_registration->set_pending_version(NULL);
+      found_registration->waiting_version();
+  found_registration->set_waiting_version(NULL);
   temp_version->SetStatus(ServiceWorkerVersion::ACTIVE);
   found_registration->set_active_version(temp_version);
   temp_version = NULL;
   storage()->UpdateToActiveState(
         found_registration,
         MakeStatusCallback(&was_called, &result));
   EXPECT_FALSE(was_called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(was_called);
   EXPECT_EQ(SERVICE_WORKER_OK, result);
@@ skipping 18 matching lines @@
   storage()->FindRegistrationForDocument(
       kDocumentUrl,
       MakeFindCallback(&was_called, &result, &found_registration));
   EXPECT_FALSE(was_called);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(was_called);
   EXPECT_EQ(SERVICE_WORKER_OK, result);
   ASSERT_TRUE(found_registration);
   EXPECT_EQ(kRegistrationId, found_registration->id());
   EXPECT_TRUE(found_registration->HasOneRef());
-  EXPECT_FALSE(found_registration->pending_version());
+  EXPECT_FALSE(found_registration->waiting_version());
   ASSERT_TRUE(found_registration->active_version());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVE,
             found_registration->active_version()->status());
   was_called = false;
 
   // Delete from storage but with a instance still live.
   EXPECT_TRUE(context_->GetLiveVersion(kRegistrationId));
   storage()->DeleteRegistration(
       kRegistrationId,
       kScope.GetOrigin(),
@@ skipping 40 matching lines @@
   scoped_refptr<ServiceWorkerRegistration> found_registration;
 
   // Create an unstored registration.
   scoped_refptr<ServiceWorkerRegistration> live_registration =
       new ServiceWorkerRegistration(
           kScope, kScript, kRegistrationId, context_ptr_);
   scoped_refptr<ServiceWorkerVersion> live_version =
       new ServiceWorkerVersion(
           live_registration, kVersionId, context_ptr_);
   live_version->SetStatus(ServiceWorkerVersion::INSTALLING);
-  live_registration->set_pending_version(live_version);
+  live_registration->set_waiting_version(live_version);
 
   // Should not be findable, including by GetAllRegistrations.
   storage()->FindRegistrationForId(
       kRegistrationId,
       kScope.GetOrigin(),
       MakeFindCallback(&was_called, &result, &found_registration));
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(was_called);
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND, result);
   EXPECT_FALSE(found_registration);
@@ skipping 118 matching lines @@
   data.registration_id = kRegistrationId;
   data.scope = kScope;
   data.script = kScript;
   data.version_id = kVersionId;
   data.is_active = false;
   std::vector<ResourceRecord> resources;
   resources.push_back(ResourceRecord(kResourceId1, kScript));
   resources.push_back(ResourceRecord(kResourceId2, kImport));
   scoped_refptr<ServiceWorkerRegistration> registration =
       storage()->GetOrCreateRegistration(data, resources);
-  registration->pending_version()->SetStatus(ServiceWorkerVersion::NEW);
+  registration->waiting_version()->SetStatus(ServiceWorkerVersion::NEW);
 
   // Add the resources ids to the uncommitted list.
   std::set<int64> resource_ids;
   resource_ids.insert(kResourceId1);
   resource_ids.insert(kResourceId2);
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             storage()->database_->WriteUncommittedResourceIds(resource_ids));
 
   // And dump something in the disk cache for them.
   WriteBasicResponse(storage(), kResourceId1);
   WriteBasicResponse(storage(), kResourceId2);
   EXPECT_TRUE(VerifyBasicResponse(storage(), kResourceId1, true));
   EXPECT_TRUE(VerifyBasicResponse(storage(), kResourceId2, true));
 
   // Storing the registration/version should take the resources ids out
   // of the uncommitted list.
   bool was_called = false;
   ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
-  storage()->StoreRegistration(registration, registration->pending_version(),
+  storage()->StoreRegistration(registration, registration->waiting_version(),
                                MakeStatusCallback(&was_called, &result));
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(was_called);
   EXPECT_EQ(SERVICE_WORKER_OK, result);
   std::set<int64> verify_ids;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             storage()->database_->GetUncommittedResourceIds(&verify_ids));
   EXPECT_TRUE(verify_ids.empty());
 
   // Deleting it should result in the resources being added to the
@@ skipping 13 matching lines @@
   verify_ids.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             storage()->database_->GetPurgeableResourceIds(&verify_ids));
   EXPECT_TRUE(verify_ids.empty());
 
   EXPECT_FALSE(VerifyBasicResponse(storage(), kResourceId1, false));
   EXPECT_FALSE(VerifyBasicResponse(storage(), kResourceId2, false));
 }
 
 }  // namespace content