Make WebContentsObserver::web_contents() public

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 255 matching lines @@
 
   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);
     if (it != GetOpener()->pending_new_windows_.end()) {
       const NewWindowInfo& new_window_info = it->second;
-      if (new_window_info.changed || !guest_web_contents()->HasOpener())
+      if (new_window_info.changed || !web_contents()->HasOpener())
         NavigateGuest(new_window_info.url.spec());
     } else {
       NOTREACHED();
     }
 
     // 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);
   }
 }
 
 void WebViewGuest::DidInitialize() {
   script_executor_.reset(
-      new ScriptExecutor(guest_web_contents(), &script_observers_));
+      new ScriptExecutor(web_contents(), &script_observers_));
 
-  notification_registrar_.Add(
-      this, content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
-      content::Source<WebContents>(guest_web_contents()));
+  notification_registrar_.Add(this,
+                              content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
+                              content::Source<WebContents>(web_contents()));
 
-  notification_registrar_.Add(
-      this, content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
-      content::Source<WebContents>(guest_web_contents()));
+  notification_registrar_.Add(this,
+                              content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
+                              content::Source<WebContents>(web_contents()));
 
   if (web_view_guest_delegate_)
     web_view_guest_delegate_->OnDidInitialize();
-  AttachWebViewHelpers(guest_web_contents());
+  AttachWebViewHelpers(web_contents());
 }
 
 void WebViewGuest::AttachWebViewHelpers(WebContents* contents) {
   if (web_view_guest_delegate_)
     web_view_guest_delegate_->OnAttachWebViewHelpers(contents);
   web_view_permission_helper_.reset(new WebViewPermissionHelper(this));
 }
 
 void WebViewGuest::DidStopLoading() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventLoadStop, args.Pass()));
 }
 
 void WebViewGuest::EmbedderDestroyed() {
   if (web_view_guest_delegate_)
     web_view_guest_delegate_->OnEmbedderDestroyed();
 }
 
 void WebViewGuest::GuestDestroyed() {
   // Clean up custom context menu items for this guest.
   if (web_view_guest_delegate_)
     web_view_guest_delegate_->OnGuestDestroyed();
   RemoveWebViewStateFromIOThread(web_contents());
 }
 
 void WebViewGuest::GuestReady() {
   // The guest RenderView should always live in an isolated guest process.
-  CHECK(guest_web_contents()->GetRenderProcessHost()->IsIsolatedGuest());
-  Send(new ExtensionMsg_SetFrameName(
-      guest_web_contents()->GetRoutingID(), name_));
+  CHECK(web_contents()->GetRenderProcessHost()->IsIsolatedGuest());
+  Send(new ExtensionMsg_SetFrameName(web_contents()->GetRoutingID(), name_));
 }
 
 void WebViewGuest::GuestSizeChangedDueToAutoSize(const gfx::Size& old_size,
                                                  const gfx::Size& new_size) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kOldHeight, old_size.height());
   args->SetInteger(webview::kOldWidth, old_size.width());
   args->SetInteger(webview::kNewHeight, new_size.height());
   args->SetInteger(webview::kNewWidth, new_size.width());
   DispatchEventToEmbedder(
@@ skipping 75 matching lines @@
   // keyboard events. In that time, the embedder may have received and processed
   // additional key events. This needs to be fixed as soon as possible.
   // See http://crbug.com/229882.
   embedder_web_contents()->GetDelegate()->HandleKeyboardEvent(
       web_contents(), event);
 }
 
 void WebViewGuest::LoadProgressChanged(content::WebContents* source,
                                        double progress) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
-  args->SetString(guestview::kUrl, guest_web_contents()->GetURL().spec());
+  args->SetString(guestview::kUrl, web_contents()->GetURL().spec());
   args->SetDouble(webview::kProgress, progress);
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventLoadProgress, args.Pass()));
 }
 
 void WebViewGuest::LoadAbort(bool is_top_level,
                              const GURL& url,
                              const std::string& error_type) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
@@ skipping 14 matching lines @@
   ReportFrameNameChange(name);
 }
 
 void WebViewGuest::CreateNewGuestWebViewWindow(
     const content::OpenURLParams& params) {
   GuestViewManager* guest_manager =
       GuestViewManager::FromBrowserContext(browser_context());
   // Set the attach params to use the same partition as the opener.
   // We pull the partition information from the site's URL, which is of the
   // form guest://site/{persist}?{partition_name}.
-  const GURL& site_url = guest_web_contents()->GetSiteInstance()->GetSiteURL();
+  const GURL& site_url = web_contents()->GetSiteInstance()->GetSiteURL();
   const std::string storage_partition_id =
       GetStoragePartitionIdFromSiteURL(site_url);
   base::DictionaryValue create_params;
   create_params.SetString(webview::kStoragePartitionId, storage_partition_id);
 
   guest_manager->CreateGuest(WebViewGuest::Type,
                              embedder_extension_id(),
                              embedder_web_contents(),
                              create_params,
                              base::Bind(&WebViewGuest::NewGuestWebViewCallback,
                                         base::Unretained(this),
                                         params));
 }
 
 void WebViewGuest::NewGuestWebViewCallback(
     const content::OpenURLParams& params,
     content::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(),
+  RequestNewWindowPermission(params.disposition,
+                             gfx::Rect(),
                              params.user_gesture,
-                             new_guest->guest_web_contents());
+                             new_guest->web_contents());
 }
 
 // TODO(fsamuel): Find a reliable way to test the 'responsive' and
 // 'unresponsive' events.
 void WebViewGuest::RendererResponsive(content::WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
-      guest_web_contents()->GetRenderProcessHost()->GetID());
+                   web_contents()->GetRenderProcessHost()->GetID());
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventResponsive, args.Pass()));
 }
 
 void WebViewGuest::RendererUnresponsive(content::WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
-      guest_web_contents()->GetRenderProcessHost()->GetID());
+                   web_contents()->GetRenderProcessHost()->GetID());
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventUnresponsive, args.Pass()));
 }
 
 void WebViewGuest::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME: {
-      DCHECK_EQ(content::Source<WebContents>(source).ptr(),
-                guest_web_contents());
-      if (content::Source<WebContents>(source).ptr() == guest_web_contents())
+      DCHECK_EQ(content::Source<WebContents>(source).ptr(), web_contents());
+      if (content::Source<WebContents>(source).ptr() == web_contents())
         LoadHandlerCalled();
       break;
     }
     case content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT: {
-      DCHECK_EQ(content::Source<WebContents>(source).ptr(),
-                guest_web_contents());
+      DCHECK_EQ(content::Source<WebContents>(source).ptr(), web_contents());
       content::ResourceRedirectDetails* resource_redirect_details =
           content::Details<content::ResourceRedirectDetails>(details).ptr();
       bool is_top_level = resource_redirect_details->resource_type ==
                           content::RESOURCE_TYPE_MAIN_FRAME;
       LoadRedirect(resource_redirect_details->url,
                    resource_redirect_details->new_url,
                    is_top_level);
       break;
     }
     default:
@@ skipping 15 matching lines @@
   if (web_view_guest_delegate_)
     web_view_guest_delegate_->Find(search_text, options, find_function);
 }
 
 void WebViewGuest::StopFinding(content::StopFindAction action) {
   if (web_view_guest_delegate_)
     web_view_guest_delegate_->StopFinding(action);
 }
 
 void WebViewGuest::Go(int relative_index) {
-  guest_web_contents()->GetController().GoToOffset(relative_index);
+  web_contents()->GetController().GoToOffset(relative_index);
 }
 
 void WebViewGuest::Reload() {
   // TODO(fsamuel): Don't check for repost because we don't want to show
   // Chromium's repost warning. We might want to implement a separate API
   // for registering a callback if a repost is about to happen.
-  guest_web_contents()->GetController().Reload(false);
+  web_contents()->GetController().Reload(false);
 }
 
 void WebViewGuest::SetUserAgentOverride(
     const std::string& user_agent_override) {
   if (!attached())
     return;
   is_overriding_user_agent_ = !user_agent_override.empty();
   if (is_overriding_user_agent_) {
     content::RecordAction(UserMetricsAction("WebView.Guest.OverrideUA"));
   }
-  guest_web_contents()->SetUserAgentOverride(user_agent_override);
+  web_contents()->SetUserAgentOverride(user_agent_override);
 }
 
 void WebViewGuest::Stop() {
-  guest_web_contents()->Stop();
+  web_contents()->Stop();
 }
 
 void WebViewGuest::Terminate() {
   content::RecordAction(UserMetricsAction("WebView.Guest.Terminate"));
   base::ProcessHandle process_handle =
-      guest_web_contents()->GetRenderProcessHost()->GetHandle();
+      web_contents()->GetRenderProcessHost()->GetHandle();
   if (process_handle)
     base::KillProcess(process_handle, content::RESULT_CODE_KILLED, false);
 }
 
 bool WebViewGuest::ClearData(const base::Time remove_since,
                              uint32 removal_mask,
                              const base::Closure& callback) {
   content::RecordAction(UserMetricsAction("WebView.Guest.ClearData"));
   content::StoragePartition* partition =
       content::BrowserContext::GetStoragePartition(
-          guest_web_contents()->GetBrowserContext(),
-          guest_web_contents()->GetSiteInstance());
+          web_contents()->GetBrowserContext(),
+          web_contents()->GetSiteInstance());
 
   if (!partition)
     return false;
 
   partition->ClearData(
       removal_mask,
       content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
       GURL(),
       content::StoragePartition::OriginMatcherFunction(),
       remove_since,
@@ skipping 15 matching lines @@
 }
 
 void WebViewGuest::DidCommitProvisionalLoadForFrame(
     content::RenderFrameHost* render_frame_host,
     const GURL& url,
     content::PageTransition transition_type) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, url.spec());
   args->SetBoolean(guestview::kIsTopLevel, !render_frame_host->GetParent());
   args->SetInteger(webview::kInternalCurrentEntryIndex,
-      guest_web_contents()->GetController().GetCurrentEntryIndex());
+                   web_contents()->GetController().GetCurrentEntryIndex());
   args->SetInteger(webview::kInternalEntryCount,
-      guest_web_contents()->GetController().GetEntryCount());
+                   web_contents()->GetController().GetEntryCount());
   args->SetInteger(webview::kInternalProcessId,
-      guest_web_contents()->GetRenderProcessHost()->GetID());
+                   web_contents()->GetRenderProcessHost()->GetID());
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventLoadCommit, args.Pass()));
   if (web_view_guest_delegate_) {
     web_view_guest_delegate_->OnDidCommitProvisionalLoadForFrame(
         !render_frame_host->GetParent());
   }
 }
 
 void WebViewGuest::DidFailProvisionalLoad(
     content::RenderFrameHost* render_frame_host,
@@ skipping 31 matching lines @@
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void WebViewGuest::RenderProcessGone(base::TerminationStatus status) {
   if (web_view_guest_delegate_)
     web_view_guest_delegate_->OnRenderProcessGone();
 
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
-                   guest_web_contents()->GetRenderProcessHost()->GetID());
+                   web_contents()->GetRenderProcessHost()->GetID());
   args->SetString(webview::kReason, TerminationStatusToString(status));
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventExit, args.Pass()));
 }
 
 void WebViewGuest::UserAgentOverrideSet(const std::string& user_agent) {
   if (!attached())
     return;
-  content::NavigationController& controller =
-      guest_web_contents()->GetController();
+  content::NavigationController& controller = web_contents()->GetController();
   content::NavigationEntry* entry = controller.GetVisibleEntry();
   if (!entry)
     return;
   entry->SetIsOverridingUserAgent(!user_agent.empty());
-  guest_web_contents()->GetController().Reload(false);
+  web_contents()->GetController().Reload(false);
 }
 
 void WebViewGuest::ReportFrameNameChange(const std::string& name) {
   name_ = name;
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(webview::kName, name);
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventFrameNameChanged, args.Pass()));
 }
 
 void WebViewGuest::LoadHandlerCalled() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventContentLoad, args.Pass()));
 }
 
 void WebViewGuest::LoadRedirect(const GURL& old_url,
                                 const GURL& new_url,
                                 bool is_top_level) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
   args->SetString(webview::kNewURL, new_url.spec());
   args->SetString(webview::kOldURL, old_url.spec());
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventLoadRedirect, args.Pass()));
 }
 
 void WebViewGuest::PushWebViewStateToIOThread() {
-  const GURL& site_url = guest_web_contents()->GetSiteInstance()->GetSiteURL();
+  const GURL& site_url = web_contents()->GetSiteInstance()->GetSiteURL();
   std::string partition_domain;
   std::string partition_id;
   bool in_memory;
   if (!GetGuestPartitionConfigForSite(
           site_url, &partition_domain, &partition_id, &in_memory)) {
     NOTREACHED();
     return;
   }
   DCHECK(embedder_extension_id() == partition_domain);
 
   WebViewRendererState::WebViewInfo web_view_info;
   web_view_info.embedder_process_id = embedder_render_process_id();
   web_view_info.instance_id = view_instance_id();
   web_view_info.partition_id = partition_id;
   web_view_info.embedder_extension_id = embedder_extension_id();
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&WebViewRendererState::AddGuest,
                  base::Unretained(WebViewRendererState::GetInstance()),
-                 guest_web_contents()->GetRenderProcessHost()->GetID(),
-                 guest_web_contents()->GetRoutingID(),
+                 web_contents()->GetRenderProcessHost()->GetID(),
+                 web_contents()->GetRoutingID(),
                  web_view_info));
 }
 
 // static
 void WebViewGuest::RemoveWebViewStateFromIOThread(
     WebContents* web_contents) {
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(
           &WebViewRendererState::RemoveGuest,
@@ skipping 84 matching lines @@
            url.scheme()) &&
        !url.SchemeIs(url::kAboutScheme)) ||
       url.SchemeIs(url::kJavaScriptScheme);
   if (scheme_is_blocked || !url.is_valid()) {
     LoadAbort(true /* is_top_level */, url,
               net::ErrorToShortString(net::ERR_ABORTED));
     return;
   }
 
   GURL validated_url(url);
-  guest_web_contents()->GetRenderProcessHost()->
-      FilterURL(false, &validated_url);
+  web_contents()->GetRenderProcessHost()->FilterURL(false, &validated_url);
   // As guests do not swap processes on navigation, only navigations to
   // normal web URLs are supported.  No protocol handlers are installed for
   // other schemes (e.g., WebUI or extensions), and no permissions or bindings
   // can be granted to the guest process.
   LoadURLWithParams(validated_url,
                     content::Referrer(),
                     content::PAGE_TRANSITION_AUTO_TOPLEVEL,
-                    guest_web_contents());
+                    web_contents());
 }
 
 bool WebViewGuest::HandleKeyboardShortcuts(
     const content::NativeWebKeyboardEvent& event) {
   if (event.type != blink::WebInputEvent::RawKeyDown)
     return false;
 
   // If the user hits the escape key without any modifiers then unlock the
   // mouse if necessary.
   if ((event.windowsKeyCode == ui::VKEY_ESCAPE) &&
       !(event.modifiers & blink::WebInputEvent::InputModifiers)) {
-    return guest_web_contents()->GotResponseToLockMouseRequest(false);
+    return web_contents()->GotResponseToLockMouseRequest(false);
   }
 
 #if defined(OS_MACOSX)
   if (event.modifiers != blink::WebInputEvent::MetaKey)
     return false;
 
   if (event.windowsKeyCode == ui::VKEY_OEM_4) {
     Go(-1);
     return true;
   }
@@ skipping 207 matching lines @@
   WebViewGuest* guest =
       WebViewGuest::From(embedder_render_process_id(), new_window_instance_id);
   if (!guest)
     return;
 
   if (!allow)
     guest->Destroy();
 }
 
 }  // namespace extensions