<webview>: Cleanup

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 "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_context.h"
@@ skipping 184 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;
 
-  content::RenderProcessHost* rph =
-      content::RenderProcessHost::FromID(embedder_process_id);
+  auto rph = content::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;
 }
 
 // static
 int WebViewGuest::GetViewInstanceId(WebContents* contents) {
-  WebViewGuest* guest = FromWebContents(contents);
+  auto guest = FromWebContents(contents);
   if (!guest)
     return guestview::kInstanceIDNone;
 
   return guest->view_instance_id();
 }
 
 const char* WebViewGuest::GetAPINamespace() const {
   return webview::kAPINamespace;
 }
 
@@ skipping 26 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.
-  GuestViewManager* guest_view_manager =
-      GuestViewManager::FromBrowserContext(
-          owner_render_process_host->GetBrowserContext());
-  content::SiteInstance* guest_site_instance =
+  auto guest_view_manager = GuestViewManager::FromBrowserContext(
+      owner_render_process_host->GetBrowserContext());
+  auto guest_site_instance =

[lazyboy, 2015/01/20 18:20:35]

This one doesn't fall within the two criteria you mention in the CL desc.

[Fady Samuel, 2015/01/20 18:28:44]

Restored.

       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);
   }
   WebContents::CreateParams params(
       owner_render_process_host->GetBrowserContext(),
@@ skipping 713 matching lines @@
   // We need to set the background opaque flag after navigation to ensure that
   // there is a RenderWidgetHostView available.
   SetAllowTransparency(allow_transparency);
 
   bool is_pending_new_window = false;
   if (GetOpener()) {
     // We need to do a navigation here if the target URL has changed between
     // the time the WebContents was created and the time it was attached.
     // We also need to do an initial navigation if a RenderView was never
     // created for the new window in cases where there is no referrer.
-    PendingWindowMap::iterator it =
-        GetOpener()->pending_new_windows_.find(this);
+    auto it = GetOpener()->pending_new_windows_.find(this);
     if (it != GetOpener()->pending_new_windows_.end()) {
       const NewWindowInfo& new_window_info = it->second;
       if (new_window_info.changed || !web_contents()->HasOpener())
         NavigateGuest(new_window_info.url.spec(), false /* force_navigation */);
 
       // Once a new guest is attached to the DOM of the embedder page, then the
       // lifetime of the new guest is no longer managed by the opener guest.
       GetOpener()->pending_new_windows_.erase(this);
 
       is_pending_new_window = true;
@@ skipping 18 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) {
-  ui_zoom::ZoomController* zoom_controller =
+  auto zoom_controller =
       ui_zoom::ZoomController::FromWebContents(web_contents());
   DCHECK(zoom_controller);
   double zoom_level = content::ZoomFactorToZoomLevel(zoom_factor);
   zoom_controller->SetZoomLevel(zoom_level);
 
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetDouble(webview::kOldZoomFactor, current_zoom_factor_);
   args->SetDouble(webview::kNewZoomFactor, zoom_factor);
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventZoomChange, args.Pass()));
@@ skipping 79 matching lines @@
 content::WebContents* WebViewGuest::OpenURLFromTab(
     content::WebContents* source,
     const content::OpenURLParams& params) {
   // If the guest wishes to navigate away prior to attachment then we save the
   // navigation to perform upon attachment. Navigation initializes a lot of
   // state that assumes an embedder exists, such as RenderWidgetHostViewGuest.
   // Navigation also resumes resource loading which we don't want to allow
   // until attachment.
   if (!attached()) {
     WebViewGuest* opener = GetOpener();
-    PendingWindowMap::iterator it =
-        opener->pending_new_windows_.find(this);
+    auto it = opener->pending_new_windows_.find(this);
     if (it == opener->pending_new_windows_.end())
       return NULL;
     const NewWindowInfo& info = it->second;
     NewWindowInfo new_window_info(params.url, info.name);
     new_window_info.changed = new_window_info.url != info.url;
     it->second = new_window_info;
     return NULL;
   }
   if (params.disposition == CURRENT_TAB) {
     // This can happen for cross-site redirects.
     LoadURLWithParams(params.url, params.referrer, params.transition, source);
     return source;
   }
 
   CreateNewGuestWebViewWindow(params);
   return NULL;
 }
 
 void WebViewGuest::WebContentsCreated(WebContents* source_contents,
                                       int opener_render_frame_id,
                                       const base::string16& frame_name,
                                       const GURL& target_url,
                                       content::WebContents* new_contents) {
-  WebViewGuest* guest = WebViewGuest::FromWebContents(new_contents);
+  auto guest = WebViewGuest::FromWebContents(new_contents);
   CHECK(guest);
   guest->SetOpener(this);
   std::string guest_name = base::UTF16ToUTF8(frame_name);
   guest->name_ = guest_name;
   pending_new_windows_.insert(
       std::make_pair(guest, NewWindowInfo(target_url, guest_name)));
 }
 
 void WebViewGuest::LoadURLWithParams(const GURL& url,
                                      const content::Referrer& referrer,
                                      ui::PageTransition transition_type,
                                      content::WebContents* web_contents) {
   content::NavigationController::LoadURLParams load_url_params(url);
   load_url_params.referrer = referrer;
   load_url_params.transition_type = transition_type;
   load_url_params.extra_headers = std::string();
   if (is_overriding_user_agent_) {
     load_url_params.override_user_agent =
         content::NavigationController::UA_OVERRIDE_TRUE;
   }
   web_contents->GetController().LoadURLWithParams(load_url_params);
 }
 
 void WebViewGuest::RequestNewWindowPermission(
     WindowOpenDisposition disposition,
     const gfx::Rect& initial_bounds,
     bool user_gesture,
     content::WebContents* new_contents) {
-  WebViewGuest* guest = WebViewGuest::FromWebContents(new_contents);
+  auto guest = WebViewGuest::FromWebContents(new_contents);
   if (!guest)
     return;
-  PendingWindowMap::iterator it = pending_new_windows_.find(guest);
+  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);
 
   base::DictionaryValue request_info;
   request_info.SetInteger(webview::kInitialHeight, initial_bounds.height());
@@ skipping 27 matching lines @@
   GURL default_url(base::StringPrintf("%s://%s/",
                                       kExtensionScheme,
                                       owner_extension_id().c_str()));
   return default_url.Resolve(src);
 }
 
 void WebViewGuest::OnWebViewNewWindowResponse(
     int new_window_instance_id,
     bool allow,
     const std::string& user_input) {
-  WebViewGuest* guest =
+  auto guest =
       WebViewGuest::From(owner_web_contents()->GetRenderProcessHost()->GetID(),
                          new_window_instance_id);
   if (!guest)
     return;
 
   if (!allow)
     guest->Destroy();
 }
 
 }  // namespace extensions