components: Change auto to not deduce raw pointers.

components/guest_view/browser/guest_view_manager.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/guest_view/browser/guest_view_manager.h"
 
 #include <tuple>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 95 matching lines @@
                                             guest_instance_id)) {
     return nullptr;
   }
   return GetGuestByInstanceID(guest_instance_id);
 }
 
 void GuestViewManager::AttachGuest(int embedder_process_id,
                                    int element_instance_id,
                                    int guest_instance_id,
                                    const base::DictionaryValue& attach_params) {
-  auto guest_view = GuestViewBase::From(embedder_process_id, guest_instance_id);
+  auto* guest_view =
+      GuestViewBase::From(embedder_process_id, guest_instance_id);
   if (!guest_view)
     return;
 
   ElementInstanceKey key(embedder_process_id, element_instance_id);
   auto it = instance_id_map_.find(key);
   // If there is an existing guest attached to the element, then destroy the
   // existing guest.
   if (it != instance_id_map_.end()) {
     int old_guest_instance_id = it->second;
     if (old_guest_instance_id == guest_instance_id)
       return;
 
-    auto old_guest_view = GuestViewBase::From(embedder_process_id,
-                                              old_guest_instance_id);
+    auto* old_guest_view =
+        GuestViewBase::From(embedder_process_id, old_guest_instance_id);
     old_guest_view->Destroy();
   }
   instance_id_map_[key] = guest_instance_id;
   reverse_instance_id_map_[guest_instance_id] = key;
   guest_view->SetAttachParams(attach_params);
 }
 
 void GuestViewManager::DetachGuest(GuestViewBase* guest) {
   if (!guest->attached())
     return;
@@ skipping 28 matching lines @@
     callback.Run(nullptr);
     return;
   }
   guest->Init(create_params, callback);
 }
 
 content::WebContents* GuestViewManager::CreateGuestWithWebContentsParams(
     const std::string& view_type,
     content::WebContents* owner_web_contents,
     const content::WebContents::CreateParams& create_params) {
-  auto guest = CreateGuestInternal(owner_web_contents, view_type);
+  auto* guest = CreateGuestInternal(owner_web_contents, view_type);
   if (!guest)
     return nullptr;
   content::WebContents::CreateParams guest_create_params(create_params);
   guest_create_params.guest_delegate = guest;
-  auto guest_web_contents = WebContents::Create(guest_create_params);
+  auto* guest_web_contents = WebContents::Create(guest_create_params);
   guest->InitWithWebContents(base::DictionaryValue(), guest_web_contents);
   return guest_web_contents;
 }
 
 content::WebContents* GuestViewManager::GetGuestByInstanceID(
     int owner_process_id,
     int element_instance_id) {
   int guest_instance_id = GetGuestInstanceIDForElementID(owner_process_id,
                                                          element_instance_id);
   if (guest_instance_id == kInstanceIDNone)
@@ skipping 16 matching lines @@
   for (const auto& guest : guest_web_contents_by_instance_id_) {
     if (guest.second->GetSiteInstance()->GetSiteURL() == guest_site)
       return guest.second->GetSiteInstance();
   }
   return nullptr;
 }
 
 bool GuestViewManager::ForEachGuest(WebContents* owner_web_contents,
                                     const GuestCallback& callback) {
   for (const auto& guest : guest_web_contents_by_instance_id_) {
-    auto guest_view = GuestViewBase::FromWebContents(guest.second);
+    auto* guest_view = GuestViewBase::FromWebContents(guest.second);
     if (guest_view->owner_web_contents() != owner_web_contents)
       continue;
 
     if (callback.Run(guest_view->web_contents()))
       return true;
   }
   return false;
 }
 
 WebContents* GuestViewManager::GetFullPageGuest(
@@ skipping 189 matching lines @@
 bool GuestViewManager::CanUseGuestInstanceID(int guest_instance_id) {
   if (guest_instance_id <= last_instance_id_removed_)
     return false;
   return !ContainsKey(removed_instance_ids_, guest_instance_id);
 }
 
 // static
 bool GuestViewManager::GetFullPageGuestHelper(
     content::WebContents** result,
     content::WebContents* guest_web_contents) {
-  auto guest_view = GuestViewBase::FromWebContents(guest_web_contents);
+  auto* guest_view = GuestViewBase::FromWebContents(guest_web_contents);
   if (guest_view && guest_view->is_full_page_plugin()) {
     *result = guest_web_contents;
     return true;
   }
   return false;
 }
 
 bool GuestViewManager::CanEmbedderAccessInstanceID(
     int embedder_render_process_id,
     int guest_instance_id) {
   // The embedder is trying to access a guest with a negative or zero
   // instance ID.
   if (guest_instance_id <= kInstanceIDNone)
     return false;
 
   // The embedder is trying to access an instance ID that has not yet been
   // allocated by GuestViewManager. This could cause instance ID
   // collisions in the future, and potentially give one embedder access to a
   // guest it does not own.
   if (guest_instance_id > current_instance_id_)
     return false;
 
   // We might get some late arriving messages at tear down. Let's let the
   // embedder tear down in peace.
   auto it = guest_web_contents_by_instance_id_.find(guest_instance_id);
   if (it == guest_web_contents_by_instance_id_.end())
     return true;
 
-  auto guest_view = GuestViewBase::FromWebContents(it->second);
+  auto* guest_view = GuestViewBase::FromWebContents(it->second);
   if (!guest_view)
     return false;
 
   return embedder_render_process_id ==
       guest_view->owner_web_contents()->GetRenderProcessHost()->GetID();
 }
 
 GuestViewManager::ElementInstanceKey::ElementInstanceKey()
     : embedder_process_id(content::ChildProcessHost::kInvalidUniqueID),
       element_instance_id(content::ChildProcessHost::kInvalidUniqueID) {
@@ skipping 22 matching lines @@
     const GuestViewCreateFunction& create_function,
     const GuestViewCleanUpFunction& cleanup_function)
     : create_function(create_function), cleanup_function(cleanup_function) {}
 
 GuestViewManager::GuestViewData::GuestViewData(const GuestViewData& other) =
     default;
 
 GuestViewManager::GuestViewData::~GuestViewData() {}
 
 }  // namespace guest_view