components: Change auto to not deduce raw pointers.

components/guest_view/browser/guest_view_base.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_base.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
@@ skipping 222 matching lines @@
   GuestViewManager::FromBrowserContext(browser_context_)->
       AddGuest(guest_instance_id_, guest_web_contents);
 
   // Populate the view instance ID if we have it on creation.
   create_params.GetInteger(kParameterInstanceId, &view_instance_id_);
 
   if (CanRunInDetachedState())
     SetUpSizing(create_params);
 
   // Observe guest zoom changes.
-  auto zoom_controller = zoom::ZoomController::FromWebContents(web_contents());
+  auto* zoom_controller = zoom::ZoomController::FromWebContents(web_contents());
   zoom_controller->AddObserver(this);
 
   // Give the derived class an opportunity to perform additional initialization.
   DidInitialize(create_params);
 }
 
 void GuestViewBase::LoadURLWithParams(
       const content::NavigationController::LoadURLParams& load_params) {
   int guest_proxy_routing_id = host()->LoadURLWithParams(load_params);
   DCHECK(guest_proxy_routing_id_ == MSG_ROUTING_NONE ||
@@ skipping 92 matching lines @@
 // static
 GuestViewBase* GuestViewBase::FromWebContents(const WebContents* web_contents) {
   WebContentsGuestViewMap* guest_map = webcontents_guestview_map.Pointer();
   auto it = guest_map->find(web_contents);
   return it == guest_map->end() ? nullptr : it->second;
 }
 
 // static
 GuestViewBase* GuestViewBase::From(int owner_process_id,
                                    int guest_instance_id) {
-  auto host = content::RenderProcessHost::FromID(owner_process_id);
+  auto* host = content::RenderProcessHost::FromID(owner_process_id);
   if (!host)
     return nullptr;
 
   WebContents* guest_web_contents =
       GuestViewManager::FromBrowserContext(host->GetBrowserContext())
           ->GetGuestByInstanceIDSafely(guest_instance_id, owner_process_id);
   if (!guest_web_contents)
     return nullptr;
 
   return GuestViewBase::FromWebContents(guest_web_contents);
@@ skipping 20 matching lines @@
 }
 
 bool GuestViewBase::ZoomPropagatesFromEmbedderToGuest() const {
   return true;
 }
 
 void GuestViewBase::SetContextMenuPosition(const gfx::Point& position) {}
 
 WebContents* GuestViewBase::CreateNewGuestWindow(
     const WebContents::CreateParams& create_params) {
-  auto guest_manager = GuestViewManager::FromBrowserContext(browser_context());
+  auto* guest_manager = GuestViewManager::FromBrowserContext(browser_context());
   return guest_manager->CreateGuestWithWebContentsParams(
       GetViewType(),
       owner_web_contents(),
       create_params);
 }
 
 void GuestViewBase::DidAttach(int guest_proxy_routing_id) {
   DCHECK(guest_proxy_routing_id_ == MSG_ROUTING_NONE ||
          guest_proxy_routing_id == guest_proxy_routing_id_);
   guest_proxy_routing_id_ = guest_proxy_routing_id;
@@ skipping 314 matching lines @@
                                                       selection_rect,
                                                       active_match_ordinal,
                                                       final_update);
   }
 }
 
 void GuestViewBase::OnZoomChanged(
     const zoom::ZoomController::ZoomChangedEventData& data) {
   if (data.web_contents == embedder_web_contents()) {
     // The embedder's zoom level has changed.
-    auto guest_zoom_controller =
+    auto* guest_zoom_controller =
         zoom::ZoomController::FromWebContents(web_contents());
     if (content::ZoomValuesEqual(data.new_zoom_level,
                                  guest_zoom_controller->GetZoomLevel())) {
       return;
     }
     // When the embedder's zoom level doesn't match the guest's, then update the
     // guest's zoom level to match.
     guest_zoom_controller->SetZoomLevel(data.new_zoom_level);
     return;
   }
@@ skipping 96 matching lines @@
   set_size_params.min_size.reset(new gfx::Size(min_width, min_height));
   set_size_params.max_size.reset(new gfx::Size(max_width, max_height));
   set_size_params.normal_size.reset(new gfx::Size(normal_width, normal_height));
 
   // Call SetSize to apply all the appropriate validation and clipping of
   // values.
   SetSize(set_size_params);
 }
 
 void GuestViewBase::SetGuestZoomLevelToMatchEmbedder() {
-  auto embedder_zoom_controller =
+  auto* embedder_zoom_controller =
       zoom::ZoomController::FromWebContents(owner_web_contents());
   if (!embedder_zoom_controller)
     return;
 
   zoom::ZoomController::FromWebContents(web_contents())
       ->SetZoomLevel(embedder_zoom_controller->GetZoomLevel());
 }
 
 void GuestViewBase::StartTrackingEmbedderZoomLevel() {
   if (!ZoomPropagatesFromEmbedderToGuest())
     return;
 
-  auto embedder_zoom_controller =
+  auto* embedder_zoom_controller =
       zoom::ZoomController::FromWebContents(owner_web_contents());
   // Chrome Apps do not have a ZoomController.
   if (!embedder_zoom_controller)
     return;
   // Listen to the embedder's zoom changes.
   embedder_zoom_controller->AddObserver(this);
 
   // Set the guest's initial zoom level to be equal to the embedder's.
   SetGuestZoomLevelToMatchEmbedder();
 }
 
 void GuestViewBase::StopTrackingEmbedderZoomLevel() {
   if (!attached() || !ZoomPropagatesFromEmbedderToGuest())
     return;
 
-  auto embedder_zoom_controller =
+  auto* embedder_zoom_controller =
       zoom::ZoomController::FromWebContents(owner_web_contents());
   // Chrome Apps do not have a ZoomController.
   if (!embedder_zoom_controller)
     return;
   embedder_zoom_controller->RemoveObserver(this);
 }
 
 void GuestViewBase::UpdateGuestSize(const gfx::Size& new_size,
                                     bool due_to_auto_resize) {
   if (due_to_auto_resize)
     GuestSizeChangedDueToAutoSize(guest_size_, new_size);
   DispatchOnResizeEvent(guest_size_, new_size);
   guest_size_ = new_size;
 }
 
 }  // namespace guest_view