Cleanup content:: prefixes in GuestView files.

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 "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/guest_view/browser/guest_view_event.h"
 #include "components/guest_view/browser/guest_view_manager.h"
@@ skipping 32 matching lines @@
 }
 SetSizeParams::~SetSizeParams() {
 }
 
 // This observer ensures that the GuestViewBase destroys itself when its
 // embedder goes away. It also tracks when the embedder's fullscreen is
 // toggled so the guest can change itself accordingly.
 class GuestViewBase::OwnerContentsObserver : public WebContentsObserver {
  public:
   OwnerContentsObserver(GuestViewBase* guest,
-                        content::WebContents* embedder_web_contents)
+                        WebContents* embedder_web_contents)
       : WebContentsObserver(embedder_web_contents),
         is_fullscreen_(false),
         destroyed_(false),
         guest_(guest) {}
 
   ~OwnerContentsObserver() override {}
 
   // WebContentsObserver implementation.
   void WebContentsDestroyed() override {
     // If the embedder is destroyed then destroy the guest.
@@ skipping 69 matching lines @@
     // If the opener is destroyed then destroy the guest.
     guest_->Destroy();
   }
 
  private:
   GuestViewBase* guest_;
 
   DISALLOW_COPY_AND_ASSIGN(OpenerLifetimeObserver);
 };
 
-GuestViewBase::GuestViewBase(content::WebContents* owner_web_contents)
+GuestViewBase::GuestViewBase(WebContents* owner_web_contents)
     : owner_web_contents_(owner_web_contents),
       browser_context_(owner_web_contents->GetBrowserContext()),
-      guest_instance_id_(
-          GuestViewManager::FromBrowserContext(browser_context_)->
-              GetNextInstanceID()),
+      guest_instance_id_(GuestViewManager::FromBrowserContext(browser_context_)
+                             ->GetNextInstanceID()),
       view_instance_id_(kInstanceIDNone),
       element_instance_id_(kInstanceIDNone),
       initialized_(false),
       is_being_destroyed_(false),
       guest_host_(nullptr),
       auto_size_enabled_(false),
       is_full_page_plugin_(false),
       guest_proxy_routing_id_(MSG_ROUTING_NONE),
       weak_ptr_factory_(this) {
   owner_host_ = GuestViewManager::FromBrowserContext(browser_context_)->
@@ skipping 19 matching lines @@
   scoped_ptr<base::DictionaryValue> params(create_params.DeepCopy());
   CreateWebContents(create_params,
                     base::Bind(&GuestViewBase::CompleteInit,
                                weak_ptr_factory_.GetWeakPtr(),
                                base::Passed(&params),
                                callback));
 }
 
 void GuestViewBase::InitWithWebContents(
     const base::DictionaryValue& create_params,
-    content::WebContents* guest_web_contents) {
+    WebContents* guest_web_contents) {
   DCHECK(guest_web_contents);
 
   // Create a ZoomController to allow the guest's contents to be zoomed.
   // Do this before adding the GuestView as a WebContents Observer so that
   // the GuestView and its derived classes can re-configure the ZoomController
   // after the latter has handled WebContentsObserver events (observers are
   // notified of events in the same order they are added as observers). For
   // example, GuestViewBase may wish to put its guest into isolated zoom mode
   // in DidNavigateMainFrame, but since ZoomController always resets to default
   // zoom mode on this event, GuestViewBase would need to do so after
@@ skipping 130 matching lines @@
   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);
   if (!host)
     return nullptr;
 
-  content::WebContents* guest_web_contents =
-      GuestViewManager::FromBrowserContext(
-          host->GetBrowserContext())->
-              GetGuestByInstanceIDSafely(guest_instance_id, owner_process_id);
+  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);
 }
 
 // static
 WebContents* GuestViewBase::GetTopLevelWebContents(WebContents* web_contents) {
   while (GuestViewBase* guest = FromWebContents(web_contents))
     web_contents = guest->owner_web_contents();
@@ skipping 10 matching lines @@
 }
 
 bool GuestViewBase::IsPreferredSizeModeEnabled() const {
   return false;
 }
 
 bool GuestViewBase::ZoomPropagatesFromEmbedderToGuest() const {
   return true;
 }
 
-content::WebContents* GuestViewBase::CreateNewGuestWindow(
-    const content::WebContents::CreateParams& create_params) {
+WebContents* GuestViewBase::CreateNewGuestWindow(
+    const WebContents::CreateParams& create_params) {
   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_);
@@ skipping 103 matching lines @@
     return;
   }
   opener_ = base::WeakPtr<GuestViewBase>();
   opener_lifetime_observer_.reset();
 }
 
 void GuestViewBase::SetGuestHost(content::GuestHost* guest_host) {
   guest_host_ = guest_host;
 }
 
-void GuestViewBase::WillAttach(content::WebContents* embedder_web_contents,
+void GuestViewBase::WillAttach(WebContents* embedder_web_contents,
                                int element_instance_id,
                                bool is_full_page_plugin,
                                const base::Closure& callback) {
   // Stop tracking the old embedder's zoom level.
   if (owner_web_contents())
     StopTrackingEmbedderZoomLevel();
 
   if (owner_web_contents_ != embedder_web_contents) {
     DCHECK_EQ(owner_contents_observer_->web_contents(), owner_web_contents_);
     owner_web_contents_ = embedder_web_contents;
@@ skipping 85 matching lines @@
 }
 
 void GuestViewBase::DeactivateContents(WebContents* web_contents) {
   if (!attached() || !embedder_web_contents()->GetDelegate())
     return;
 
   embedder_web_contents()->GetDelegate()->DeactivateContents(
       embedder_web_contents());
 }
 
-void GuestViewBase::ContentsMouseEvent(content::WebContents* source,
+void GuestViewBase::ContentsMouseEvent(WebContents* source,
                                        const gfx::Point& location,
                                        bool motion) {
   if (!attached() || !embedder_web_contents()->GetDelegate())
     return;
 
   embedder_web_contents()->GetDelegate()->ContentsMouseEvent(
       embedder_web_contents(), location, motion);
 }
 
 void GuestViewBase::ContentsZoomChange(bool zoom_in) {
   ui_zoom::PageZoom::Zoom(
       embedder_web_contents(),
       zoom_in ? content::PAGE_ZOOM_IN : content::PAGE_ZOOM_OUT);
 }
 
 void GuestViewBase::HandleKeyboardEvent(
     WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
   if (!attached())
     return;
 
   // Send the keyboard events back to the embedder to reprocess them.
   embedder_web_contents()->GetDelegate()->
       HandleKeyboardEvent(embedder_web_contents(), event);
 }
 
-void GuestViewBase::LoadingStateChanged(content::WebContents* source,
+void GuestViewBase::LoadingStateChanged(WebContents* source,
                                         bool to_different_document) {
   if (!attached() || !embedder_web_contents()->GetDelegate())
     return;
 
   embedder_web_contents()->GetDelegate()->LoadingStateChanged(
       embedder_web_contents(), to_different_document);
 }
 
 content::ColorChooser* GuestViewBase::OpenColorChooser(
     WebContents* web_contents,
@@ skipping 12 matching lines @@
     return;
 
   embedder_web_contents()->GetDelegate()->RunFileChooser(web_contents, params);
 }
 
 bool GuestViewBase::ShouldFocusPageAfterCrash() {
   // Focus is managed elsewhere.
   return false;
 }
 
-bool GuestViewBase::PreHandleGestureEvent(content::WebContents* source,
-                                         const blink::WebGestureEvent& event) {
+bool GuestViewBase::PreHandleGestureEvent(WebContents* source,
+                                          const blink::WebGestureEvent& event) {
   return event.type == blink::WebGestureEvent::GesturePinchBegin ||
       event.type == blink::WebGestureEvent::GesturePinchUpdate ||
       event.type == blink::WebGestureEvent::GesturePinchEnd;
 }
 
-void GuestViewBase::UpdatePreferredSize(
-    content::WebContents* target_web_contents,
-    const gfx::Size& pref_size) {
+void GuestViewBase::UpdatePreferredSize(WebContents* target_web_contents,
+                                        const gfx::Size& pref_size) {
   // In theory it's not necessary to check IsPreferredSizeModeEnabled() because
   // there will only be events if it was enabled in the first place. However,
   // something else may have turned on preferred size mode, so double check.
   DCHECK_EQ(web_contents(), target_web_contents);
   if (IsPreferredSizeModeEnabled()) {
     OnPreferredSizeChanged(pref_size);
   }
 }
 
-void GuestViewBase::UpdateTargetURL(content::WebContents* source,
-                                    const GURL& url) {
+void GuestViewBase::UpdateTargetURL(WebContents* source, const GURL& url) {
   if (!attached() || !embedder_web_contents()->GetDelegate())
     return;
 
   embedder_web_contents()->GetDelegate()->UpdateTargetURL(
       embedder_web_contents(), url);
 }
 
 bool GuestViewBase::ShouldResumeRequestsForCreatedWindow() {
   return false;
 }
@@ skipping 45 matching lines @@
   while (!pending_events_.empty()) {
     linked_ptr<GuestViewEvent> event_ptr = pending_events_.front();
     pending_events_.pop_front();
     event_ptr.release()->Dispatch(this, view_instance_id_);
   }
 }
 
 void GuestViewBase::CompleteInit(
     scoped_ptr<base::DictionaryValue> create_params,
     const WebContentsCreatedCallback& callback,
-    content::WebContents* guest_web_contents) {
+    WebContents* guest_web_contents) {
   if (!guest_web_contents) {
     // The derived class did not create a WebContents so this class serves no
     // purpose. Let's self-destruct.
     delete this;
     callback.Run(nullptr);
     return;
   }
   InitWithWebContents(*create_params, guest_web_contents);
   callback.Run(guest_web_contents);
 }
@@ skipping 87 matching lines @@
 
   auto embedder_zoom_controller =
       ui_zoom::ZoomController::FromWebContents(owner_web_contents());
   // Chrome Apps do not have a ZoomController.
   if (!embedder_zoom_controller)
     return;
   embedder_zoom_controller->RemoveObserver(this);
 }
 
 }  // namespace guest_view