Service Worker: Use auto / range-based loop for container objects.

content/browser/service_worker/service_worker_storage.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 "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 349 matching lines @@
           base::Bind(&ServiceWorkerStorage::DidFindRegistrationForPattern,
                      weak_factory_.GetWeakPtr(),
                      scope,
                      callback)));
 }
 
 ServiceWorkerRegistration* ServiceWorkerStorage::GetUninstallingRegistration(
     const GURL& scope) {
   if (state_ != INITIALIZED || !context_)
     return NULL;
-  for (RegistrationRefsById::const_iterator it =
-           uninstalling_registrations_.begin();
-       it != uninstalling_registrations_.end();
-       ++it) {
-    if (it->second->pattern() == scope) {
-      DCHECK(it->second->is_uninstalling());
-      return it->second.get();
+  for (const auto& registration : uninstalling_registrations_) {
+    if (registration.second->pattern() == scope) {
+      DCHECK(registration.second->is_uninstalling());
+      return registration.second.get();
     }
   }
   return NULL;
 }
 
 void ServiceWorkerStorage::FindRegistrationForId(
     int64 registration_id,
     const GURL& origin,
     const FindRegistrationCallback& callback) {
   if (!LazyInitialize(base::Bind(
@@ skipping 480 matching lines @@
 void ServiceWorkerStorage::NotifyDoneInstallingRegistration(
       ServiceWorkerRegistration* registration,
       ServiceWorkerVersion* version,
       ServiceWorkerStatusCode status) {
   installing_registrations_.erase(registration->id());
   if (status != SERVICE_WORKER_OK && version) {
     ResourceList resources;
     version->script_cache_map()->GetResources(&resources);
 
     std::set<int64> ids;
-    for (size_t i = 0; i < resources.size(); ++i)
-      ids.insert(resources[i].resource_id);
+    for (const auto& resource : resources)
+      ids.insert(resource.resource_id);
 
     database_task_manager_->GetTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(
             &ServiceWorkerDatabase::PurgeUncommittedResourceIds),
             base::Unretained(database_.get()),
             ids));
   }
 }
 
@@ skipping 112 matching lines @@
     registered_origins_.swap(data->origins);
     disk_cache_migration_needed_ = data->disk_cache_migration_needed;
     old_disk_cache_deletion_needed_ = data->old_disk_cache_deletion_needed;
     state_ = INITIALIZED;
   } else {
     DVLOG(2) << "Failed to initialize: "
              << ServiceWorkerDatabase::StatusToString(status);
     ScheduleDeleteAndStartOver();
   }
 
-  for (std::vector<base::Closure>::const_iterator it = pending_tasks_.begin();
-       it != pending_tasks_.end(); ++it) {
-    RunSoon(FROM_HERE, *it);
-  }
+  for (const auto& task : pending_tasks_)
+    RunSoon(FROM_HERE, task);
   pending_tasks_.clear();
 }
 
 void ServiceWorkerStorage::DidFindRegistrationForDocument(
     const GURL& document_url,
     const FindRegistrationCallback& callback,
     int64 callback_id,
     const ServiceWorkerDatabase::RegistrationData& data,
     const ResourceList& resources,
     ServiceWorkerDatabase::Status status) {
@@ skipping 113 matching lines @@
   std::set<int64> registration_ids;
   std::vector<scoped_refptr<ServiceWorkerRegistration>> registrations;
   size_t index = 0;
   for (const auto& registration_data : *registration_data_list) {
     registration_ids.insert(registration_data.registration_id);
     registrations.push_back(GetOrCreateRegistration(
         registration_data, resources_list->at(index++)));
   }
 
   // Add unstored registrations that are being installed.
-  for (RegistrationRefsById::const_iterator it =
-           installing_registrations_.begin();
-       it != installing_registrations_.end(); ++it) {
+  for (const auto& registration : installing_registrations_) {
     if ((!origin_filter.is_valid() ||
-         it->second->pattern().GetOrigin() == origin_filter) &&
-        registration_ids.insert(it->first).second) {
-      registrations.push_back((it->second).get());
+         registration.second->pattern().GetOrigin() == origin_filter) &&
+        registration_ids.insert(registration.first).second) {
+      registrations.push_back(registration.second);
     }
   }
 
   callback.Run(registrations);
 }
 
 void ServiceWorkerStorage::DidGetRegistrationsInfos(
     const GetRegistrationsInfosCallback& callback,
     RegistrationList* registration_data_list,
     const GURL& origin_filter,
@@ skipping 44 matching lines @@
     } else {
       info.waiting_version.status = ServiceWorkerVersion::INSTALLED;
       info.waiting_version.script_url = registration_data.script;
       info.waiting_version.version_id = registration_data.version_id;
       info.waiting_version.registration_id = registration_data.registration_id;
     }
     infos.push_back(info);
   }
 
   // Add unstored registrations that are being installed.
-  for (RegistrationRefsById::const_iterator it =
-           installing_registrations_.begin();
-       it != installing_registrations_.end(); ++it) {
+  for (const auto& registration : installing_registrations_) {
     if ((!origin_filter.is_valid() ||
-         it->second->pattern().GetOrigin() == origin_filter) &&
-        pushed_registrations.insert(it->first).second) {
-      infos.push_back(it->second->GetInfo());
+         registration.second->pattern().GetOrigin() == origin_filter) &&
+        pushed_registrations.insert(registration.first).second) {
+      infos.push_back(registration.second->GetInfo());
     }
   }
 
   callback.Run(infos);
 }
 
 void ServiceWorkerStorage::DidStoreRegistration(
     const StatusCallback& callback,
     const ServiceWorkerDatabase::RegistrationData& new_version,
     const GURL& origin,
@@ skipping 146 matching lines @@
 ServiceWorkerRegistration*
 ServiceWorkerStorage::FindInstallingRegistrationForDocument(
     const GURL& document_url) {
   DCHECK(!document_url.has_ref());
 
   LongestScopeMatcher matcher(document_url);
   ServiceWorkerRegistration* match = NULL;
 
   // TODO(nhiroki): This searches over installing registrations linearly and it
   // couldn't be scalable. Maybe the regs should be partitioned by origin.
-  for (RegistrationRefsById::const_iterator it =
-           installing_registrations_.begin();
-       it != installing_registrations_.end(); ++it) {
-    if (matcher.MatchLongest(it->second->pattern()))
-      match = it->second.get();
-  }
+  for (const auto& registration : installing_registrations_)
+    if (matcher.MatchLongest(registration.second->pattern()))
+      match = registration.second.get();
   return match;
 }
 
 ServiceWorkerRegistration*
 ServiceWorkerStorage::FindInstallingRegistrationForPattern(
     const GURL& scope) {
-  for (RegistrationRefsById::const_iterator it =
-           installing_registrations_.begin();
-       it != installing_registrations_.end(); ++it) {
-    if (it->second->pattern() == scope)
-      return it->second.get();
-  }
+  for (const auto& registration : installing_registrations_)
+    if (registration.second->pattern() == scope)
+      return registration.second.get();
   return NULL;
 }
 
 ServiceWorkerRegistration*
 ServiceWorkerStorage::FindInstallingRegistrationForId(
     int64 registration_id) {
   RegistrationRefsById::const_iterator found =
       installing_registrations_.find(registration_id);
   if (found == installing_registrations_.end())
     return NULL;
@@ skipping 106 matching lines @@
     LOG(ERROR) << "Failed to open the serviceworker diskcache: "
                << net::ErrorToString(rv);
     ScheduleDeleteAndStartOver();
   }
   ServiceWorkerMetrics::CountInitDiskCacheResult(rv == net::OK);
 }
 
 void ServiceWorkerStorage::StartPurgingResources(
     const std::vector<int64>& ids) {
   DCHECK(has_checked_for_stale_resources_);
-  for (size_t i = 0; i < ids.size(); ++i)
-    purgeable_resource_ids_.push_back(ids[i]);
+  for (const auto& id : ids)
+    purgeable_resource_ids_.push_back(id);
   ContinuePurgingResources();
 }
 
 void ServiceWorkerStorage::StartPurgingResources(
     const ResourceList& resources) {
   DCHECK(has_checked_for_stale_resources_);
-  for (size_t i = 0; i < resources.size(); ++i)
-    purgeable_resource_ids_.push_back(resources[i].resource_id);
+  for (const auto& resource : resources)
+    purgeable_resource_ids_.push_back(resource.resource_id);
   ContinuePurgingResources();
 }
 
 void ServiceWorkerStorage::ContinuePurgingResources() {
   if (purgeable_resource_ids_.empty() || is_purge_pending_)
     return;
 
   // Do one at a time until we're done, use RunSoon to avoid recursion when
   // DoomEntry returns immediately.
   is_purge_pending_ = true;
@@ skipping 209 matching lines @@
                                             newly_purgeable_resources,
                                             status));
 }
 
 void ServiceWorkerStorage::FindForDocumentInDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     const GURL& document_url,
     const FindInDBCallback& callback) {
   GURL origin = document_url.GetOrigin();
-  RegistrationList registrations;
-  ServiceWorkerDatabase::Status status =
-      database->GetRegistrationsForOrigin(origin, &registrations, nullptr);
+  RegistrationList registration_data_list;
+  ServiceWorkerDatabase::Status status = database->GetRegistrationsForOrigin(
+      origin, &registration_data_list, nullptr);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    ServiceWorkerDatabase::RegistrationData(),
                    ResourceList(),
                    status));
     return;
   }
 
   ServiceWorkerDatabase::RegistrationData data;
   ResourceList resources;
   status = ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND;
 
   // Find one with a pattern match.
   LongestScopeMatcher matcher(document_url);
   int64 match = kInvalidServiceWorkerRegistrationId;
-  for (size_t i = 0; i < registrations.size(); ++i) {
-    if (matcher.MatchLongest(registrations[i].scope))
-      match = registrations[i].registration_id;
-  }
-
+  for (const auto& registration_data : registration_data_list)
+    if (matcher.MatchLongest(registration_data.scope))
+      match = registration_data.registration_id;
   if (match != kInvalidServiceWorkerRegistrationId)
     status = database->ReadRegistration(match, origin, &data, &resources);
 
   original_task_runner->PostTask(
       FROM_HERE,
       base::Bind(callback, data, resources, status));
 }
 
 void ServiceWorkerStorage::FindForPatternInDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     const GURL& scope,
     const FindInDBCallback& callback) {
   GURL origin = scope.GetOrigin();
-  RegistrationList registrations;
-  ServiceWorkerDatabase::Status status =
-      database->GetRegistrationsForOrigin(origin, &registrations, nullptr);
+  RegistrationList registration_data_list;
+  ServiceWorkerDatabase::Status status = database->GetRegistrationsForOrigin(
+      origin, &registration_data_list, nullptr);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    ServiceWorkerDatabase::RegistrationData(),
                    ResourceList(),
                    status));
     return;
   }
 
   // Find one with an exact matching scope.
   ServiceWorkerDatabase::RegistrationData data;
   ResourceList resources;
   status = ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND;
-  for (RegistrationList::const_iterator it = registrations.begin();
-       it != registrations.end(); ++it) {
-    if (scope != it->scope)
+  for (const auto& registration_data : registration_data_list) {
+    if (scope != registration_data.scope)
       continue;
-    status = database->ReadRegistration(it->registration_id, origin,
-                                        &data, &resources);
+    status = database->ReadRegistration(registration_data.registration_id,
+                                        origin, &data, &resources);
     break;  // We're done looping.
   }
 
   original_task_runner->PostTask(
       FROM_HERE,
       base::Bind(callback, data, resources, status));
 }
 
 void ServiceWorkerStorage::FindForIdInDB(
     ServiceWorkerDatabase* database,
@@ skipping 116 matching lines @@
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully.";
   ServiceWorkerMetrics::RecordDeleteAndStartOverResult(
       ServiceWorkerMetrics::DELETE_OK);
   callback.Run(SERVICE_WORKER_OK);
 }
 
 }  // namespace content