Cleanup content:: prefixes in GuestView files.

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 "components/browsing_data/storage_partition_http_cache_data_remover.h"
@@ skipping 218 matching lines @@
   // Clean up content scripts for the WebView.
   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(content::WebContents* owner_web_contents) {
+GuestViewBase* WebViewGuest::Create(WebContents* owner_web_contents) {
   return new WebViewGuest(owner_web_contents);
 }
 
 // static
 bool WebViewGuest::GetGuestPartitionConfigForSite(
     const GURL& site,
     std::string* partition_domain,
     std::string* partition_name,
     bool* in_memory) {
   if (!site.SchemeIs(content::kGuestScheme))
@@ skipping 283 matching lines @@
 
 void WebViewGuest::HandleKeyboardEvent(
     WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
   if (HandleKeyboardShortcuts(event))
     return;
 
   GuestViewBase::HandleKeyboardEvent(source, event);
 }
 
-bool WebViewGuest::PreHandleGestureEvent(content::WebContents* source,
+bool WebViewGuest::PreHandleGestureEvent(WebContents* source,
                                          const blink::WebGestureEvent& event) {
   return !allow_scaling_ && GuestViewBase::PreHandleGestureEvent(source, event);
 }
 
-void WebViewGuest::LoadProgressChanged(content::WebContents* source,
-                                       double progress) {
+void WebViewGuest::LoadProgressChanged(WebContents* source, double progress) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guest_view::kUrl, web_contents()->GetURL().spec());
   args->SetDouble(webview::kProgress, progress);
   DispatchEventToView(
       new GuestViewEvent(webview::kEventLoadProgress, args.Pass()));
 }
 
 void WebViewGuest::LoadAbort(bool is_top_level,
                              const GURL& url,
                              int error_code,
@@ skipping 21 matching lines @@
   create_params.SetString(webview::kStoragePartitionId, storage_partition_id);
 
   guest_manager->CreateGuest(WebViewGuest::Type,
                              embedder_web_contents(),
                              create_params,
                              base::Bind(&WebViewGuest::NewGuestWebViewCallback,
                                         weak_ptr_factory_.GetWeakPtr(),
                                         params));
 }
 
-void WebViewGuest::NewGuestWebViewCallback(
-    const content::OpenURLParams& params,
-    content::WebContents* guest_web_contents) {
+void WebViewGuest::NewGuestWebViewCallback(const content::OpenURLParams& params,
+                                           WebContents* guest_web_contents) {
   WebViewGuest* new_guest = WebViewGuest::FromWebContents(guest_web_contents);
   new_guest->SetOpener(this);
 
   // Take ownership of |new_guest|.
   pending_new_windows_.insert(
       std::make_pair(new_guest, NewWindowInfo(params.url, std::string())));
 
   // Request permission to show the new window.
   RequestNewWindowPermission(params.disposition,
                              gfx::Rect(),
                              params.user_gesture,
                              new_guest->web_contents());
 }
 
 // TODO(fsamuel): Find a reliable way to test the 'responsive' and
 // 'unresponsive' events.
-void WebViewGuest::RendererResponsive(content::WebContents* source) {
+void WebViewGuest::RendererResponsive(WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
                    web_contents()->GetRenderProcessHost()->GetID());
   DispatchEventToView(
       new GuestViewEvent(webview::kEventResponsive, args.Pass()));
 }
 
-void WebViewGuest::RendererUnresponsive(content::WebContents* source) {
+void WebViewGuest::RendererUnresponsive(WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
                    web_contents()->GetRenderProcessHost()->GetID());
   DispatchEventToView(
       new GuestViewEvent(webview::kEventUnresponsive, args.Pass()));
 }
 
 void WebViewGuest::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
@@ skipping 102 matching lines @@
         partition, remove_since, base::Time::Now())
         ->Remove(cache_removal_done_callback);
 
     return true;
   }
 
   ClearDataInternal(remove_since, removal_mask, callback);
   return true;
 }
 
-WebViewGuest::WebViewGuest(content::WebContents* owner_web_contents)
+WebViewGuest::WebViewGuest(WebContents* owner_web_contents)
     : GuestView<WebViewGuest>(owner_web_contents),
       rules_registry_id_(RulesRegistryService::kInvalidRulesRegistryID),
       find_helper_(this),
       is_overriding_user_agent_(false),
       allow_transparency_(false),
       javascript_dialog_helper_(this),
       allow_scaling_(false),
       is_guest_fullscreen_(false),
       is_embedder_fullscreen_(false),
       last_fullscreen_permission_was_allowed_by_embedder_(false),
@@ skipping 164 matching lines @@
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(
           &WebViewRendererState::RemoveGuest,
           base::Unretained(WebViewRendererState::GetInstance()),
           web_contents->GetRenderProcessHost()->GetID(),
           web_contents->GetRoutingID()));
 }
 
 void WebViewGuest::RequestMediaAccessPermission(
-    content::WebContents* source,
+    WebContents* source,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback) {
   web_view_permission_helper_->RequestMediaAccessPermission(source,
                                                             request,
                                                             callback);
 }
 
-bool WebViewGuest::CheckMediaAccessPermission(content::WebContents* source,
+bool WebViewGuest::CheckMediaAccessPermission(WebContents* source,
                                               const GURL& security_origin,
                                               content::MediaStreamType type) {
   return web_view_permission_helper_->CheckMediaAccessPermission(
       source, security_origin, type);
 }
 
 void WebViewGuest::CanDownload(
     const GURL& url,
     const std::string& request_method,
     const base::Callback<void(bool)>& callback) {
@@ skipping 246 matching lines @@
   load_params.virtual_url_for_data_url = virtual_gurl;
   load_params.override_user_agent =
       content::NavigationController::UA_OVERRIDE_INHERIT;
 
   // Navigate to the data URL.
   GuestViewBase::LoadURLWithParams(load_params);
 
   return true;
 }
 
-void WebViewGuest::AddNewContents(content::WebContents* source,
-                                  content::WebContents* new_contents,
+void WebViewGuest::AddNewContents(WebContents* source,
+                                  WebContents* new_contents,
                                   WindowOpenDisposition disposition,
                                   const gfx::Rect& initial_rect,
                                   bool user_gesture,
                                   bool* was_blocked) {
   if (was_blocked)
     *was_blocked = false;
   RequestNewWindowPermission(disposition,
                              initial_rect,
                              user_gesture,
                              new_contents);
 }
 
-content::WebContents* WebViewGuest::OpenURLFromTab(
-    content::WebContents* source,
+WebContents* WebViewGuest::OpenURLFromTab(
+    WebContents* source,
     const content::OpenURLParams& params) {
   // Most navigations should be handled by WebViewGuest::LoadURLWithParams,
   // which takes care of blocking chrome:// URLs and other web-unsafe schemes.
   // (NavigateGuest and CreateNewGuestWebViewWindow also go through
   // LoadURLWithParams.)
   //
   // We make an exception here for context menu items, since the Language
   // Settings item uses a browser-initiated navigation to a chrome:// URL.
   // These can be passed to the embedder's WebContentsDelegate so that the
   // browser performs the action for the <webview>.
@@ skipping 46 matching lines @@
   // keyboard/mouse combinations are used to open a link in a new tab/window.
   // 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,
-                                      content::WebContents* new_contents) {
+                                      WebContents* 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(content::WebContents* web_contents,
+void WebViewGuest::EnterFullscreenModeForTab(WebContents* web_contents,
                                              const GURL& origin) {
   // Ask the embedder for permission.
   base::DictionaryValue request_info;
   request_info.SetString(webview::kOrigin, origin.spec());
   web_view_permission_helper_->RequestPermission(
       WEB_VIEW_PERMISSION_TYPE_FULLSCREEN, request_info,
       base::Bind(&WebViewGuest::OnFullscreenPermissionDecided,
                  weak_ptr_factory_.GetWeakPtr()),
       false /* allowed_by_default */);
 
   // TODO(lazyboy): Right now the guest immediately goes fullscreen within its
   // bounds. If the embedder denies the permission then we will see a flicker.
   // Once we have the ability to "cancel" a renderer/ fullscreen request:
   // http://crbug.com/466854 this won't be necessary and we should be
   // Calling SetFullscreenState(true) once the embedder allowed the request.
   // Otherwise we would cancel renderer/ fullscreen if the embedder denied.
   SetFullscreenState(true);
 }
 
-void WebViewGuest::ExitFullscreenModeForTab(
-    content::WebContents* web_contents) {
+void WebViewGuest::ExitFullscreenModeForTab(WebContents* web_contents) {
   SetFullscreenState(false);
 }
 
 bool WebViewGuest::IsFullscreenForTabOrPending(
-    const content::WebContents* web_contents) const {
+    const WebContents* web_contents) const {
   return is_guest_fullscreen_;
 }
 
 void WebViewGuest::LoadURLWithParams(
     const GURL& url,
     const content::Referrer& referrer,
     ui::PageTransition transition_type,
     const GlobalRequestID& transferred_global_request_id,
     bool force_navigation) {
   if (!url.is_valid()) {
@@ skipping 35 matching lines @@
   load_url_params.transferred_global_request_id = transferred_global_request_id;
   if (is_overriding_user_agent_) {
     load_url_params.override_user_agent =
         content::NavigationController::UA_OVERRIDE_TRUE;
   }
   GuestViewBase::LoadURLWithParams(load_url_params);
 
   src_ = validated_url;
 }
 
-void WebViewGuest::RequestNewWindowPermission(
-    WindowOpenDisposition disposition,
-    const gfx::Rect& initial_bounds,
-    bool user_gesture,
-    content::WebContents* new_contents) {
+void WebViewGuest::RequestNewWindowPermission(WindowOpenDisposition disposition,
+                                              const gfx::Rect& initial_bounds,
+                                              bool user_gesture,
+                                              WebContents* 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();
@@ skipping 75 matching lines @@
     scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
     DispatchEventToView(
         new GuestViewEvent(webview::kEventExitFullscreen, args.Pass()));
   }
   // Since we changed fullscreen state, sending a Resize message ensures that
   // renderer/ sees the change.
   web_contents()->GetRenderViewHost()->WasResized();
 }
 
 }  // namespace extensions