extensions: Change auto to not deduce raw pointers.

extensions/browser/guest_view/web_view/web_view_guest.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 "extensions/browser/guest_view/web_view/web_view_guest.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 221 matching lines @@
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &RemoveWebViewEventListenersOnIOThread,
           browser_context,
           embedder_process_id,
           view_instance_id));
 
   // Clean up content scripts for the WebView.
-  auto csm = WebViewContentScriptManager::Get(browser_context);
+  auto* csm = WebViewContentScriptManager::Get(browser_context);
   csm->RemoveAllContentScriptsForWebView(embedder_process_id, view_instance_id);
 
   // Allow an extensions browser client to potentially perform more cleanup.
   ExtensionsBrowserClient::Get()->CleanUpWebView(
       browser_context, embedder_process_id, view_instance_id);
 }
 
 // static
 GuestViewBase* WebViewGuest::Create(WebContents* owner_web_contents) {
   return new WebViewGuest(owner_web_contents);
@@ skipping 43 matching lines @@
     int webview_instance_id) {
   bool is_web_view = embedder_process_id && webview_instance_id;
   if (!is_web_view)
     return RulesRegistryService::kDefaultRulesRegistryID;
 
   WebViewKey key = std::make_pair(embedder_process_id, webview_instance_id);
   auto it = web_view_key_to_id_map.Get().find(key);
   if (it != web_view_key_to_id_map.Get().end())
     return it->second;
 
-  auto rph = RenderProcessHost::FromID(embedder_process_id);
+  auto* rph = RenderProcessHost::FromID(embedder_process_id);
   int rules_registry_id =
       RulesRegistryService::Get(rph->GetBrowserContext())->
           GetNextRulesRegistryID();
   web_view_key_to_id_map.Get()[key] = rules_registry_id;
   return rules_registry_id;
 }
 
 bool WebViewGuest::CanRunInDetachedState() const {
   return true;
 }
@@ skipping 23 matching lines @@
   std::string partition_domain = GetOwnerSiteURL().host();
   GURL guest_site(base::StringPrintf("%s://%s/%s?%s",
                                      content::kGuestScheme,
                                      partition_domain.c_str(),
                                      persist_storage ? "persist" : "",
                                      url_encoded_partition.c_str()));
 
   // If we already have a webview tag in the same app using the same storage
   // partition, we should use the same SiteInstance so the existing tag and
   // the new tag can script each other.
-  auto guest_view_manager = GuestViewManager::FromBrowserContext(
+  auto* guest_view_manager = GuestViewManager::FromBrowserContext(
       owner_render_process_host->GetBrowserContext());
   scoped_refptr<content::SiteInstance> guest_site_instance =
       guest_view_manager->GetGuestSiteInstance(guest_site);
   if (!guest_site_instance) {
     // Create the SiteInstance in a new BrowsingInstance, which will ensure
     // that webview tags are also not allowed to send messages across
     // different partitions.
     guest_site_instance = content::SiteInstance::CreateForURL(
         owner_render_process_host->GetBrowserContext(), guest_site);
   }
@@ skipping 619 matching lines @@
     bool user_gesture,
     bool last_unlocked_by_target,
     const base::Callback<void(bool)>& callback) {
   web_view_permission_helper_->RequestPointerLockPermission(
       user_gesture,
       last_unlocked_by_target,
       callback);
 }
 
 void WebViewGuest::SignalWhenReady(const base::Closure& callback) {
-  auto manager = WebViewContentScriptManager::Get(browser_context());
+  auto* manager = WebViewContentScriptManager::Get(browser_context());
   manager->SignalOnScriptsLoaded(callback);
 }
 
 bool WebViewGuest::ShouldHandleFindRequestsForEmbedder() const {
   if (web_view_guest_delegate_)
     return web_view_guest_delegate_->ShouldHandleFindRequestsForEmbedder();
   return false;
 }
 
 void WebViewGuest::WillAttachToEmbedder() {
@@ skipping 145 matching lines @@
 
 void WebViewGuest::SetName(const std::string& name) {
   if (name_ == name)
     return;
   name_ = name;
 
   Send(new ExtensionMsg_SetFrameName(routing_id(), name_));
 }
 
 void WebViewGuest::SetZoom(double zoom_factor) {
-  auto zoom_controller = ZoomController::FromWebContents(web_contents());
+  auto* zoom_controller = ZoomController::FromWebContents(web_contents());
   DCHECK(zoom_controller);
   double zoom_level = content::ZoomFactorToZoomLevel(zoom_factor);
   zoom_controller->SetZoomLevel(zoom_level);
 }
 
 void WebViewGuest::SetZoomMode(ZoomController::ZoomMode zoom_mode) {
   ZoomController::FromWebContents(web_contents())->SetZoomMode(zoom_mode);
 }
 
 void WebViewGuest::SetAllowTransparency(bool allow) {
@@ skipping 143 matching lines @@
   // This code path is also taken on client-side redirects from about:blank.
   CreateNewGuestWebViewWindow(params);
   return nullptr;
 }
 
 void WebViewGuest::WebContentsCreated(WebContents* source_contents,
                                       int opener_render_frame_id,
                                       const std::string& frame_name,
                                       const GURL& target_url,
                                       WebContents* new_contents) {
-  auto guest = WebViewGuest::FromWebContents(new_contents);
+  auto* guest = WebViewGuest::FromWebContents(new_contents);
   CHECK(guest);
   guest->SetOpener(this);
   guest->name_ = frame_name;
   pending_new_windows_.insert(
       std::make_pair(guest, NewWindowInfo(target_url, frame_name)));
 }
 
 void WebViewGuest::EnterFullscreenModeForTab(WebContents* web_contents,
                                              const GURL& origin) {
   // Ask the embedder for permission.
@@ skipping 71 matching lines @@
   }
   GuestViewBase::LoadURLWithParams(load_url_params);
 
   src_ = validated_url;
 }
 
 void WebViewGuest::RequestNewWindowPermission(WindowOpenDisposition disposition,
                                               const gfx::Rect& initial_bounds,
                                               bool user_gesture,
                                               WebContents* new_contents) {
-  auto guest = WebViewGuest::FromWebContents(new_contents);
+  auto* guest = WebViewGuest::FromWebContents(new_contents);
   if (!guest)
     return;
   auto it = pending_new_windows_.find(guest);
   if (it == pending_new_windows_.end())
     return;
   const NewWindowInfo& new_window_info = it->second;
 
   // Retrieve the opener partition info if we have it.
   const GURL& site_url = new_contents->GetSiteInstance()->GetSiteURL();
   std::string storage_partition_id = GetStoragePartitionIdFromSiteURL(site_url);
@@ skipping 31 matching lines @@
   GURL default_url(base::StringPrintf("%s://%s/",
                                       kExtensionScheme,
                                       owner_host().c_str()));
   return default_url.Resolve(src);
 }
 
 void WebViewGuest::OnWebViewNewWindowResponse(
     int new_window_instance_id,
     bool allow,
     const std::string& user_input) {
-  auto guest =
+  auto* guest =
       WebViewGuest::From(owner_web_contents()->GetRenderProcessHost()->GetID(),
                          new_window_instance_id);
   if (!guest)
     return;
 
   if (!allow)
     guest->Destroy();
 }
 
 void WebViewGuest::OnFullscreenPermissionDecided(
@@ skipping 22 matching lines @@
     std::unique_ptr<base::DictionaryValue> args(new base::DictionaryValue());
     DispatchEventToView(base::WrapUnique(
         new GuestViewEvent(webview::kEventExitFullscreen, std::move(args))));
   }
   // Since we changed fullscreen state, sending a Resize message ensures that
   // renderer/ sees the change.
   web_contents()->GetRenderViewHost()->GetWidget()->WasResized();
 }
 
 }  // namespace extensions