components: Change auto to not deduce raw pointers.

components/component_updater/component_updater_service.cc

 // Copyright 2014 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 "components/component_updater/component_updater_service.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 216 matching lines @@
 
   return OnDemandUpdateInternal(id);
 }
 
 bool CrxUpdateService::OnDemandUpdateWithCooldown(const std::string& id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DCHECK(GetComponent(id));
 
   // Check if the request is too soon.
-  const auto component_state(GetComponentState(id));
+  auto* component_state(GetComponentState(id));
   if (component_state) {
     base::TimeDelta delta = base::Time::Now() - component_state->last_check;
     if (delta < base::TimeDelta::FromSeconds(config_->OnDemandDelay()))
       return false;
   }
 
   return OnDemandUpdateInternal(id);
 }
 
 bool CrxUpdateService::OnDemandUpdateInternal(const std::string& id) {
@@ skipping 14 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   UMA_HISTOGRAM_ENUMERATION("ComponentUpdater.Calls", UPDATE_TYPE_AUTOMATIC,
                             UPDATE_TYPE_COUNT);
 
   std::vector<std::string> secure_ids;    // Requires HTTPS for update checks.
   std::vector<std::string> unsecure_ids;  // Can fallback to HTTP.
   for (const auto id : components_order_) {
     DCHECK(components_.find(id) != components_.end());
 
-    auto component(GetComponent(id));
+    auto* component(GetComponent(id));
     if (!component || component->requires_network_encryption)
       secure_ids.push_back(id);
     else
       unsecure_ids.push_back(id);
   }
 
   if (!unsecure_ids.empty()) {
     update_client_->Update(
         unsecure_ids,
         base::Bind(&CrxUpdateService::OnUpdate, base::Unretained(this)),
@@ skipping 37 matching lines @@
 
   return false;
 }
 
 void CrxUpdateService::OnUpdate(const std::vector<std::string>& ids,
                                 std::vector<CrxComponent>* components) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(components->empty());
 
   for (const auto& id : ids) {
-    const auto registered_component(GetComponent(id));
+    auto* registered_component(GetComponent(id));
     if (registered_component) {
       components->push_back(*registered_component);
     }
   }
 }
 
 void CrxUpdateService::OnUpdateComplete(const base::TimeTicks& start_time,
                                         int error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(1) << "Update completed with error " << error;
 
   UMA_HISTOGRAM_BOOLEAN("ComponentUpdater.UpdateCompleteResult", error != 0);
   UMA_HISTOGRAM_LONG_TIMES_100("ComponentUpdater.UpdateCompleteTime",
                                base::TimeTicks::Now() - start_time);
 
   for (const auto id : components_pending_unregistration_) {
     if (!update_client_->IsUpdating(id)) {
-      const auto component = GetComponent(id);
+      auto* component = GetComponent(id);
       if (component)
         DoUnregisterComponent(*component);
     }
   }
 }
 
 void CrxUpdateService::OnEvent(Events event, const std::string& id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Unblock all throttles for the component.
@@ skipping 10 matching lines @@
   if (!update_client_->GetCrxUpdateState(id, &update_item))
     return;
 
   // Update the state of the item.
   auto it = component_states_.find(id);
   DCHECK(it != component_states_.end());
   it->second = update_item;
 
   // Update the component registration with the new version.
   if (event == Observer::Events::COMPONENT_UPDATED) {
-    auto component(const_cast<CrxComponent*>(GetComponent(id)));
+    auto* component(const_cast<CrxComponent*>(GetComponent(id)));
     if (component) {
       component->version = update_item.next_version;
       component->fingerprint = update_item.next_fp;
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // The component update factory. Using the component updater as a singleton
 // is the job of the browser process.
 // TODO(sorin): consider making this a singleton.
 std::unique_ptr<ComponentUpdateService> ComponentUpdateServiceFactory(
     const scoped_refptr<Configurator>& config) {
   DCHECK(config);
   auto update_client = update_client::UpdateClientFactory(config);
   return base::WrapUnique(
       new CrxUpdateService(config, std::move(update_client)));
 }
 
 }  // namespace component_updater