<webview>: Cleanup

extensions/browser/guest_view/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 "extensions/browser/guest_view/guest_view_base.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/ui/zoom/page_zoom.h"
 #include "components/ui/zoom/zoom_controller.h"
@@ skipping 240 matching lines @@
     rvh->DisableAutoResize(element_size_);
     guest_size_ = element_size_;
     GuestSizeChangedDueToAutoSize(guest_size_, element_size_);
   }
 }
 
 // static
 void GuestViewBase::RegisterGuestViewType(
     const std::string& view_type,
     const GuestCreationCallback& callback) {
-  GuestViewCreationMap::iterator it =
-      guest_view_registry.Get().find(view_type);
+  auto it = guest_view_registry.Get().find(view_type);
   DCHECK(it == guest_view_registry.Get().end());
   guest_view_registry.Get()[view_type] = callback;
 }
 
 // static
 GuestViewBase* GuestViewBase::Create(
     content::BrowserContext* browser_context,
     content::WebContents* owner_web_contents,
     int guest_instance_id,
     const std::string& view_type) {
   if (guest_view_registry.Get().empty())
     RegisterGuestViewTypes();
 
-  GuestViewCreationMap::iterator it =
-      guest_view_registry.Get().find(view_type);
+  auto it = guest_view_registry.Get().find(view_type);
   if (it == guest_view_registry.Get().end()) {
     NOTREACHED();
     return NULL;
   }
   return it->second.Run(browser_context, owner_web_contents, guest_instance_id);
 }
 
 // static
 GuestViewBase* GuestViewBase::FromWebContents(WebContents* web_contents) {
   WebContentsGuestViewMap* guest_map = webcontents_guestview_map.Pointer();
-  WebContentsGuestViewMap::iterator it = guest_map->find(web_contents);
+  auto it = guest_map->find(web_contents);
   return it == guest_map->end() ? NULL : it->second;
 }
 
 // static
-GuestViewBase* GuestViewBase::From(int embedder_process_id,
+GuestViewBase* GuestViewBase::From(int owner_process_id,
                                    int guest_instance_id) {
-  content::RenderProcessHost* host =
-      content::RenderProcessHost::FromID(embedder_process_id);
+  auto host = content::RenderProcessHost::FromID(owner_process_id);
   if (!host)
     return NULL;
 
   content::WebContents* guest_web_contents =
       GuestViewManager::FromBrowserContext(host->GetBrowserContext())->
-          GetGuestByInstanceIDSafely(guest_instance_id, embedder_process_id);
+          GetGuestByInstanceIDSafely(guest_instance_id, owner_process_id);
   if (!guest_web_contents)
     return NULL;
 
   return GuestViewBase::FromWebContents(guest_web_contents);
 }
 
 // static
 bool GuestViewBase::IsGuest(WebContents* web_contents) {
   return !!GuestViewBase::FromWebContents(web_contents);
 }
 
 bool GuestViewBase::IsAutoSizeSupported() const {
   return false;
 }
 
 bool GuestViewBase::IsPreferredSizeModeEnabled() const {
   return false;
 }
 
 bool GuestViewBase::IsDragAndDropEnabled() const {
   return false;
 }
 
 bool GuestViewBase::ZoomPropagatesFromEmbedderToGuest() const {
   return true;
 }
 
 content::WebContents* GuestViewBase::CreateNewGuestWindow(
     const content::WebContents::CreateParams& create_params) {
-  GuestViewManager* 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) {
   opener_lifetime_observer_.reset();
 
   SetUpAutoSize(*attach_params());
@@ skipping 292 matching lines @@
   // values.
   SetAutoSize(auto_size_enabled,
               gfx::Size(min_width, min_height),
               gfx::Size(max_width, max_height));
 }
 
 void GuestViewBase::StartTrackingEmbedderZoomLevel() {
   if (!ZoomPropagatesFromEmbedderToGuest())
     return;
 
-  ui_zoom::ZoomController* zoom_controller =
+  auto embedder_zoom_controller =
       ui_zoom::ZoomController::FromWebContents(owner_web_contents());
   // Chrome Apps do not have a ZoomController.
-  if (!zoom_controller)
+  if (!embedder_zoom_controller)
     return;
   // Listen to the embedder's zoom changes.
-  zoom_controller->AddObserver(this);
+  embedder_zoom_controller->AddObserver(this);
   // Set the guest's initial zoom level to be equal to the embedder's.
   ui_zoom::ZoomController::FromWebContents(web_contents())
-      ->SetZoomLevel(zoom_controller->GetZoomLevel());
+      ->SetZoomLevel(embedder_zoom_controller->GetZoomLevel());
 }
 
 void GuestViewBase::StopTrackingEmbedderZoomLevel() {
   if (!attached() || !ZoomPropagatesFromEmbedderToGuest())
     return;
 
-  ui_zoom::ZoomController* zoom_controller =
+  auto embedder_zoom_controller =
       ui_zoom::ZoomController::FromWebContents(owner_web_contents());
-  if (!zoom_controller)
+  // Chrome Apps do not have a ZoomController.
+  if (!embedder_zoom_controller)
     return;
-  zoom_controller->RemoveObserver(this);
+  embedder_zoom_controller->RemoveObserver(this);
 }
 
 // static
 void GuestViewBase::RegisterGuestViewTypes() {
   AppViewGuest::Register();
   ExtensionOptionsGuest::Register();
   MimeHandlerViewGuest::Register();
   SurfaceWorkerGuest::Register();
   WebViewGuest::Register();
 }
 
 }  // namespace extensions