Define the public version of the browser side RenderProcessHost interface. This interface is not ...

content/browser/renderer_host/render_view_host.cc

 // Copyright (c) 2011 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 "content/browser/renderer_host/render_view_host.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/json/json_reader.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/browser/browser_context.h"
 #include "content/browser/browser_message_filter.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/cross_site_request_manager.h"
 #include "content/browser/host_zoom_map.h"
 #include "content/browser/in_process_webkit/session_storage_namespace.h"
 #include "content/browser/power_save_blocker.h"
-#include "content/browser/renderer_host/render_process_host.h"
+#include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_observer.h"
 #include "content/browser/renderer_host/render_widget_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/browser/site_instance.h"
 #include "content/browser/user_metrics.h"
 #include "content/common/desktop_notification_messages.h"
 #include "content/common/drag_messages.h"
 #include "content/common/speech_input_messages.h"
 #include "content/common/swapped_out_messages.h"
@@ skipping 44 matching lines @@
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderViewHost, public:
 
 // static
 RenderViewHost* RenderViewHost::FromID(int render_process_id,
                                        int render_view_id) {
-  RenderProcessHost* process = RenderProcessHost::FromID(render_process_id);
+  content::RenderProcessHost* process =
+      content::RenderProcessHost::FromID(render_process_id);
   if (!process)
     return NULL;
   RenderWidgetHost* widget = static_cast<RenderWidgetHost*>(
       process->GetListenerByID(render_view_id));
   if (!widget || !widget->IsRenderView())
     return NULL;
   return static_cast<RenderViewHost*>(widget);
 }
 
 RenderViewHost::RenderViewHost(SiteInstance* instance,
@@ skipping 13 matching lines @@
       is_waiting_for_beforeunload_ack_(false),
       is_waiting_for_unload_ack_(false),
       unload_ack_is_for_cross_site_transition_(false),
       are_javascript_messages_suppressed_(false),
       sudden_termination_allowed_(false),
       session_storage_namespace_(session_storage),
       save_accessibility_tree_for_testing_(false),
       render_view_termination_status_(base::TERMINATION_STATUS_STILL_RUNNING) {
   if (!session_storage_namespace_) {
     session_storage_namespace_ = new SessionStorageNamespace(
-        process()->browser_context()->GetWebKitContext());
+        process()->GetBrowserContext()->GetWebKitContext());
   }
 
   DCHECK(instance_);
   CHECK(delegate_);  // http://crbug.com/82827
 
   process()->EnableSendQueue();
 
   content::GetContentClient()->browser()->RenderViewHostCreated(this);
 
   content::NotificationService::current()->Notify(
@@ skipping 10 matching lines @@
       content::NOTIFICATION_RENDER_VIEW_HOST_DELETED,
       content::Source<RenderViewHost>(this),
       content::NotificationService::NoDetails());
 
   ClearPowerSaveBlockers();
 
   delegate()->RenderViewDeleted(this);
 
   // Be sure to clean up any leftover state from cross-site requests.
   CrossSiteRequestManager::GetInstance()->SetHasPendingCrossSiteRequest(
-      process()->id(), routing_id(), false);
+      process()->GetID(), routing_id(), false);
 }
 
 bool RenderViewHost::CreateRenderView(const string16& frame_name) {
   DCHECK(!IsRenderViewLive()) << "Creating view twice";
 
   // The process may (if we're sharing a process with another host that already
   // initialized it) or may not (we have our own process or the old process
   // crashed) have been initialized. Calling Init multiple times will be
   // ignored, so this is safe.
   if (!process()->Init(renderer_accessible()))
     return false;
   DCHECK(process()->HasConnection());
-  DCHECK(process()->browser_context());
+  DCHECK(process()->GetBrowserContext());
 
   renderer_initialized_ = true;
 
   process()->SetCompositingSurface(routing_id(),
                                    GetCompositingSurface());
 
   ViewMsg_New_Params params;
   params.parent_window = GetNativeViewId();
   params.renderer_preferences =
-      delegate_->GetRendererPrefs(process()->browser_context());
+      delegate_->GetRendererPrefs(process()->GetBrowserContext());
   params.web_preferences = delegate_->GetWebkitPrefs();
   params.view_id = routing_id();
   params.session_storage_namespace_id = session_storage_namespace_->id();
   params.frame_name = frame_name;
   Send(new ViewMsg_New(params));
 
   // If it's enabled, tell the renderer to set up the Javascript bindings for
   // sending messages back to the browser.
   Send(new ViewMsg_AllowBindings(routing_id(), enabled_bindings_));
   // Let our delegate know that we created a RenderView.
   delegate_->RenderViewCreated(this);
 
   FOR_EACH_OBSERVER(
       RenderViewHostObserver, observers_, RenderViewHostInitialized());
 
   return true;
 }
 
 bool RenderViewHost::IsRenderViewLive() const {
   return process()->HasConnection() && renderer_initialized_;
 }
 
 void RenderViewHost::SyncRendererPrefs() {
   Send(new ViewMsg_SetRendererPrefs(routing_id(),
                                     delegate_->GetRendererPrefs(
-                                        process()->browser_context())));
+                                        process()->GetBrowserContext())));
 }
 
 void RenderViewHost::Navigate(const ViewMsg_Navigate_Params& params) {
   ChildProcessSecurityPolicy::GetInstance()->GrantRequestURL(
-      process()->id(), params.url);
+      process()->GetID(), params.url);
 
   ViewMsg_Navigate* nav_message = new ViewMsg_Navigate(routing_id(), params);
 
   // Only send the message if we aren't suspended at the start of a cross-site
   // request.
   if (navigations_suspended_) {
     // Shouldn't be possible to have a second navigation while suspended, since
     // navigations will only be suspended during a cross-site request.  If a
     // second navigation occurs, TabContents will cancel this pending RVH
     // create a new pending RVH.
@@ skipping 102 matching lines @@
   // to false in SetNavigationsSuspended if we swap back in.
   is_swapped_out_ = true;
 
   // This will be set back to false in OnSwapOutACK, just before we replace
   // this RVH with the pending RVH.
   is_waiting_for_unload_ack_ = true;
   // Start the hang monitor in case the renderer hangs in the unload handler.
   StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kUnloadTimeoutMS));
 
   ViewMsg_SwapOut_Params params;
-  params.closing_process_id = process()->id();
+  params.closing_process_id = process()->GetID();
   params.closing_route_id = routing_id();
   params.new_render_process_host_id = new_render_process_host_id;
   params.new_request_id = new_request_id;
   if (IsRenderViewLive()) {
     Send(new ViewMsg_SwapOut(routing_id(), params));
   } else {
     // This RenderViewHost doesn't have a live renderer, so just skip the unload
     // event.  We must notify the ResourceDispatcherHost on the IO thread,
     // which we will do through the RenderProcessHost's widget helper.
     process()->CrossSiteSwapOutACK(params);
@@ skipping 41 matching lines @@
   is_waiting_for_beforeunload_ack_ = false;
   is_waiting_for_unload_ack_ = false;
 
   sudden_termination_allowed_ = true;
   delegate_->Close(this);
 }
 
 void RenderViewHost::SetHasPendingCrossSiteRequest(bool has_pending_request,
                                                    int request_id) {
   CrossSiteRequestManager::GetInstance()->SetHasPendingCrossSiteRequest(
-      process()->id(), routing_id(), has_pending_request);
+      process()->GetID(), routing_id(), has_pending_request);
   pending_request_id_ = request_id;
 }
 
 int RenderViewHost::GetPendingRequestId() {
   return pending_request_id_;
 }
 
 void RenderViewHost::DragTargetDragEnter(
     const WebDropData& drop_data,
     const gfx::Point& client_pt,
     const gfx::Point& screen_pt,
     WebDragOperationsMask operations_allowed) {
   // Grant the renderer the ability to load the drop_data.
   ChildProcessSecurityPolicy* policy =
       ChildProcessSecurityPolicy::GetInstance();
-  policy->GrantRequestURL(process()->id(), drop_data.url);
+  policy->GrantRequestURL(process()->GetID(), drop_data.url);
   for (std::vector<string16>::const_iterator iter(drop_data.filenames.begin());
        iter != drop_data.filenames.end(); ++iter) {
     FilePath path = FilePath::FromWStringHack(UTF16ToWideHack(*iter));
-    policy->GrantRequestURL(process()->id(),
+    policy->GrantRequestURL(process()->GetID(),
                             net::FilePathToFileURL(path));
-    policy->GrantReadFile(process()->id(), path);
+    policy->GrantReadFile(process()->GetID(), path);
 
     // Allow dragged directories to be enumerated by the child process.
     // Note that we can't tell a file from a directory at this point.
-    policy->GrantReadDirectory(process()->id(), path);
+    policy->GrantReadDirectory(process()->GetID(), path);
   }
   Send(new DragMsg_TargetDragEnter(routing_id(), drop_data, client_pt,
                                    screen_pt, operations_allowed));
 }
 
 void RenderViewHost::DragTargetDragOver(
     const gfx::Point& client_pt, const gfx::Point& screen_pt,
     WebDragOperationsMask operations_allowed) {
   Send(new DragMsg_TargetDragOver(routing_id(), client_pt, screen_pt,
                                   operations_allowed));
@@ skipping 82 matching lines @@
       &observer, content::NOTIFICATION_EXECUTE_JAVASCRIPT_RESULT,
       content::Source<RenderViewHost>(this));
   MessageLoop* loop = MessageLoop::current();
   loop->Run();
   return observer.value()->DeepCopy();
 }
 
 void RenderViewHost::JavaScriptDialogClosed(IPC::Message* reply_msg,
                                             bool success,
                                             const string16& user_input) {
-  process()->set_ignore_input_events(false);
+  process()->SetIgnoreInputEvents(false);
   bool is_waiting =
       is_waiting_for_beforeunload_ack_ || is_waiting_for_unload_ack_;
   if (is_waiting)
     StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kUnloadTimeoutMS));
 
   ViewHostMsg_RunJavaScriptMessage::WriteReplyParams(reply_msg,
                                                      success, user_input);
   Send(reply_msg);
 
   // If we are waiting for an unload or beforeunload ack and the user has
@@ skipping 25 matching lines @@
       false, WebDragOperationNone));
 }
 
 void RenderViewHost::DragSourceSystemDragEnded() {
   Send(new DragMsg_SourceSystemDragEnded(routing_id()));
 }
 
 void RenderViewHost::AllowBindings(int bindings_flags) {
   if (bindings_flags & content::BINDINGS_POLICY_WEB_UI) {
     ChildProcessSecurityPolicy::GetInstance()->GrantWebUIBindings(
-        process()->id());
+        process()->GetID());
   }
 
   enabled_bindings_ |= bindings_flags;
   if (renderer_initialized_)
     Send(new ViewMsg_AllowBindings(routing_id(), enabled_bindings_));
 }
 
 void RenderViewHost::SetWebUIProperty(const std::string& name,
                                       const std::string& value) {
   DCHECK(enabled_bindings_  & content::BINDINGS_POLICY_WEB_UI);
@@ skipping 22 matching lines @@
   Send(new ViewMsg_SetInitialFocus(routing_id(), reverse));
 }
 
 void RenderViewHost::FilesSelectedInChooser(
     const std::vector<FilePath>& files,
     int permissions) {
   // Grant the security access requested to the given files.
   for (std::vector<FilePath>::const_iterator file = files.begin();
        file != files.end(); ++file) {
     ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
-        process()->id(), *file, permissions);
+        process()->GetID(), *file, permissions);
   }
   Send(new ViewMsg_RunFileChooserResponse(routing_id(), files));
 }
 
 void RenderViewHost::DirectoryEnumerationFinished(
     int request_id,
     const std::vector<FilePath>& files) {
   // Grant the security access requested to the given files.
   for (std::vector<FilePath>::const_iterator file = files.begin();
        file != files.end(); ++file) {
     ChildProcessSecurityPolicy::GetInstance()->GrantReadFile(
-        process()->id(), *file);
+        process()->GetID(), *file);
   }
   Send(new ViewMsg_EnumerateDirectoryResponse(routing_id(),
                                               request_id,
                                               files));
 }
 
 void RenderViewHost::LoadStateChanged(const GURL& url,
                                       const net::LoadStateWithParam& load_state,
                                       uint64 upload_position,
                                       uint64 upload_size) {
   delegate_->LoadStateChanged(url, load_state, upload_position, upload_size);
 }
 
 bool RenderViewHost::SuddenTerminationAllowed() const {
-  return sudden_termination_allowed_ || process()->sudden_termination_allowed();
+  return sudden_termination_allowed_ || process()->SuddenTerminationAllowed();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderViewHost, IPC message handlers:
 
 bool RenderViewHost::OnMessageReceived(const IPC::Message& msg) {
   if (!BrowserMessageFilter::CheckCanDispatchOnUI(msg, this))
     return true;
 
   // Filter out most IPC messages if this renderer is swapped out.
@@ skipping 225 matching lines @@
   }
 
   // If we're waiting for an unload ack from this renderer and we receive a
   // Navigate message, then the renderer was navigating before it received the
   // unload request.  It will either respond to the unload request soon or our
   // timer will expire.  Either way, we should ignore this message, because we
   // have already committed to closing this renderer.
   if (is_waiting_for_unload_ack_)
     return;
 
-  const int renderer_id = process()->id();
+  const int renderer_id = process()->GetID();
   ChildProcessSecurityPolicy* policy =
       ChildProcessSecurityPolicy::GetInstance();
   // Without this check, an evil renderer can trick the browser into creating
   // a navigation entry for a banned URL.  If the user clicks the back button
   // followed by the forward button (or clicks reload, or round-trips through
   // session restore, etc), we'll think that the browser commanded the
   // renderer to load the URL and grant the renderer the privileges to request
   // the URL.  To prevent this attack, we block the renderer from inserting
   // banned URLs into the navigation controller in the first place.
   FilterURL(policy, renderer_id, &validated_params.url);
@@ skipping 81 matching lines @@
 }
 
 void RenderViewHost::OnMsgContextMenu(const ContextMenuParams& params) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (!view)
     return;
 
   // Validate the URLs in |params|.  If the renderer can't request the URLs
   // directly, don't show them in the context menu.
   ContextMenuParams validated_params(params);
-  int renderer_id = process()->id();
+  int renderer_id = process()->GetID();
   ChildProcessSecurityPolicy* policy =
       ChildProcessSecurityPolicy::GetInstance();
 
   // We don't validate |unfiltered_link_url| so that this field can be used
   // when users want to copy the original link URL.
   FilterURL(policy, renderer_id, &validated_params.link_url);
   FilterURL(policy, renderer_id, &validated_params.src_url);
   FilterURL(policy, renderer_id, &validated_params.page_url);
   FilterURL(policy, renderer_id, &validated_params.frame_url);
 
   view->ShowContextMenu(validated_params);
 }
 
 void RenderViewHost::OnMsgToggleFullscreen(bool enter_fullscreen) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   delegate_->ToggleFullscreenMode(enter_fullscreen);
 }
 
 void RenderViewHost::OnMsgOpenURL(const GURL& url,
                                   const GURL& referrer,
                                   WindowOpenDisposition disposition,
                                   int64 source_frame_id) {
   GURL validated_url(url);
   FilterURL(ChildProcessSecurityPolicy::GetInstance(),
-            process()->id(), &validated_url);
+            process()->GetID(), &validated_url);
 
   delegate_->RequestOpenURL(
       validated_url, referrer, disposition, source_frame_id);
 }
 
 void RenderViewHost::OnMsgDidContentsPreferredSizeChange(
     const gfx::Size& new_size) {
   delegate_->UpdatePreferredSize(new_size);
 }
 
@@ skipping 27 matching lines @@
 }
 
 void RenderViewHost::OnMsgRunJavaScriptMessage(
     const string16& message,
     const string16& default_prompt,
     const GURL& frame_url,
     const int flags,
     IPC::Message* reply_msg) {
   // While a JS message dialog is showing, tabs in the same process shouldn't
   // process input events.
-  process()->set_ignore_input_events(true);
+  process()->SetIgnoreInputEvents(true);
   StopHangMonitorTimeout();
   delegate_->RunJavaScriptMessage(this, message, default_prompt, frame_url,
                                   flags, reply_msg,
                                   &are_javascript_messages_suppressed_);
 }
 
 void RenderViewHost::OnMsgRunBeforeUnloadConfirm(const GURL& frame_url,
                                                  const string16& message,
                                                  IPC::Message* reply_msg) {
   // While a JS before unload dialog is showing, tabs in the same process
   // shouldn't process input events.
-  process()->set_ignore_input_events(true);
+  process()->SetIgnoreInputEvents(true);
   StopHangMonitorTimeout();
   delegate_->RunBeforeUnloadConfirm(this, message, reply_msg);
 }
 
 void RenderViewHost::OnMsgStartDragging(
     const WebDropData& drop_data,
     WebDragOperationsMask drag_operations_mask,
     const SkBitmap& image,
     const gfx::Point& image_offset) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (!view)
     return;
 
   GURL drag_url = drop_data.url;
   GURL html_base_url = drop_data.html_base_url;
 
   ChildProcessSecurityPolicy* policy =
       ChildProcessSecurityPolicy::GetInstance();
 
   // Allow drag of Javascript URLs to enable bookmarklet drag to bookmark bar.
   if (!drag_url.SchemeIs(chrome::kJavaScriptScheme))
-    FilterURL(policy, process()->id(), &drag_url);
-  FilterURL(policy, process()->id(), &html_base_url);
+    FilterURL(policy, process()->GetID(), &drag_url);
+  FilterURL(policy, process()->GetID(), &html_base_url);
 
   if (drag_url != drop_data.url || html_base_url != drop_data.html_base_url) {
     WebDropData drop_data_copy = drop_data;
     drop_data_copy.url = drag_url;
     drop_data_copy.html_base_url = html_base_url;
     view->StartDragging(drop_data_copy, drag_operations_mask, image,
                         image_offset);
   } else {
     view->StartDragging(drop_data, drag_operations_mask, image, image_offset);
   }
@@ skipping 296 matching lines @@
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_EXECUTE_JAVASCRIPT_RESULT,
       content::Source<RenderViewHost>(this),
       content::Details<std::pair<int, Value*> >(&details));
 }
 
 void RenderViewHost::OnDidZoomURL(double zoom_level,
                                   bool remember,
                                   const GURL& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  HostZoomMap* host_zoom_map = process()->browser_context()->GetHostZoomMap();
+  HostZoomMap* host_zoom_map = process()->GetBrowserContext()->
+      GetHostZoomMap();
   if (remember) {
     host_zoom_map->SetZoomLevel(net::GetHostOrSpecFromURL(url), zoom_level);
     // Notify renderers from this browser context.
-    for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
+    for (content::RenderProcessHost::iterator i(
+            content::RenderProcessHost::AllHostsIterator());
          !i.IsAtEnd(); i.Advance()) {
-      RenderProcessHost* render_process_host = i.GetCurrentValue();
-      if (render_process_host->browser_context()->GetHostZoomMap()->
+      content::RenderProcessHost* render_process_host = i.GetCurrentValue();
+      if (render_process_host->GetBrowserContext()->GetHostZoomMap()->
           GetOriginal() == host_zoom_map) {
         render_process_host->Send(
             new ViewMsg_SetZoomLevelForCurrentURL(url, zoom_level));
       }
     }
   } else {
     host_zoom_map->SetTemporaryZoomLevel(
-        process()->id(), routing_id(), zoom_level);
+        process()->GetID(), routing_id(), zoom_level);
   }
 }
 
 void RenderViewHost::OnMediaNotification(int64 player_cookie,
                                          bool has_video,
                                          bool has_audio,
                                          bool is_playing) {
   if (is_playing) {
     PowerSaveBlocker* blocker = NULL;
     if (has_video) {
       blocker = new PowerSaveBlocker(
           PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep);
     } else if (has_audio) {
       blocker = new PowerSaveBlocker(
           PowerSaveBlocker::kPowerSaveBlockPreventSystemSleep);
     }
 
     if (blocker)
       power_save_blockers_[player_cookie] = blocker;
   } else {
     delete power_save_blockers_[player_cookie];
     power_save_blockers_.erase(player_cookie);
   }
 }
 
 void RenderViewHost::OnRequestDesktopNotificationPermission(
     const GURL& source_origin, int callback_context) {
   content::GetContentClient()->browser()->RequestDesktopNotificationPermission(
-      source_origin, callback_context, process()->id(), routing_id());
+      source_origin, callback_context, process()->GetID(), routing_id());
 }
 
 void RenderViewHost::OnShowDesktopNotification(
     const content::ShowDesktopNotificationHostMsgParams& params) {
   // Disallow HTML notifications from javascript: and file: schemes as this
   // allows unwanted cross-domain access.
   GURL url = params.contents_url;
   if (params.is_html &&
       (url.SchemeIs(chrome::kJavaScriptScheme) ||
        url.SchemeIs(chrome::kFileScheme))) {
     return;
   }
 
   content::GetContentClient()->browser()->ShowDesktopNotification(
-      params, process()->id(), routing_id(), false);
+      params, process()->GetID(), routing_id(), false);
 }
 
 void RenderViewHost::OnCancelDesktopNotification(int notification_id) {
   content::GetContentClient()->browser()->CancelDesktopNotification(
-      process()->id(), routing_id(), notification_id);
+      process()->GetID(), routing_id(), notification_id);
 }
 
 #if defined(OS_MACOSX)
 void RenderViewHost::OnMsgShowPopup(
     const ViewHostMsg_ShowPopup_Params& params) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (view) {
     view->ShowPopupMenu(params.bounds,
                         params.item_height,
                         params.item_font_size,
@@ skipping 11 matching lines @@
 
 void RenderViewHost::OnWebUISend(const GURL& source_url,
                                  const std::string& name,
                                  const base::ListValue& args) {
   delegate_->WebUISend(this, source_url, name, args);
 }
 
 void RenderViewHost::ClearPowerSaveBlockers() {
   STLDeleteValues(&power_save_blockers_);
 }