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

content/browser/renderer_host/render_widget_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_widget_host.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/i18n/rtl.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/accessibility/browser_accessibility_state.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/renderer_host/backing_store.h"
 #include "content/browser/renderer_host/backing_store_manager.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_widget_helper.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/browser/user_metrics.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/public/browser/notification_service.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
@@ skipping 39 matching lines @@
              == new_event.hasPreciseScrollingDeltas &&
          last_event.phase == new_event.phase &&
          last_event.momentumPhase == new_event.momentumPhase;
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHost
 
-RenderWidgetHost::RenderWidgetHost(RenderProcessHost* process,
+RenderWidgetHost::RenderWidgetHost(content::RenderProcessHost* process,
                                    int routing_id)
     : renderer_initialized_(false),
       renderer_accessible_(false),
       view_(NULL),
       process_(process),
       routing_id_(routing_id),
       is_loading_(false),
       is_hidden_(false),
       is_accelerated_compositing_active_(false),
       repaint_ack_pending_(false),
@@ skipping 167 matching lines @@
   // Don't bother reporting hung state when we aren't the active tab.
   StopHangMonitorTimeout();
 
   // If we have a renderer, then inform it that we are being hidden so it can
   // reduce its resource utilization.
   Send(new ViewMsg_WasHidden(routing_id_));
 
   GpuProcessHost::SendOnIO(
       0,
       content::CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH,
-      new GpuMsg_VisibilityChanged(routing_id_, process()->id(), false));
+      new GpuMsg_VisibilityChanged(routing_id_, process()->GetID(), false));
 
   // Tell the RenderProcessHost we were hidden.
   process_->WidgetHidden();
 
   bool is_visible = false;
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
       content::Source<RenderWidgetHost>(this),
       content::Details<bool>(&is_visible));
 }
@@ skipping 15 matching lines @@
     needs_repainting = true;
     needs_repainting_on_restore_ = false;
   } else {
     needs_repainting = false;
   }
   Send(new ViewMsg_WasRestored(routing_id_, needs_repainting));
 
   GpuProcessHost::SendOnIO(
       0,
       content::CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH,
-      new GpuMsg_VisibilityChanged(routing_id_, process()->id(), true));
+      new GpuMsg_VisibilityChanged(routing_id_, process()->GetID(), true));
 
   process_->WidgetRestored();
 
   bool is_visible = true;
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
       content::Source<RenderWidgetHost>(this),
       content::Details<bool>(&is_visible));
 
   // It's possible for our size to be out of sync with the renderer. The
@@ skipping 226 matching lines @@
 void RenderWidgetHost::StopHangMonitorTimeout() {
   time_when_considered_hung_ = Time();
   RendererIsResponsive();
 
   // We do not bother to stop the hung_renderer_timer_ here in case it will be
   // started again shortly, which happens to be the common use case.
 }
 
 void RenderWidgetHost::ForwardMouseEvent(const WebMouseEvent& mouse_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardMouseEvent");
-  if (ignore_input_events_ || process_->ignore_input_events())
+  if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   // Avoid spamming the renderer with mouse move events.  It is important
   // to note that WM_MOUSEMOVE events are anyways synthetic, but since our
   // thread is able to rapidly consume WM_MOUSEMOVE events, we may get way
   // more WM_MOUSEMOVE events than we wish to send to the renderer.
   if (mouse_event.type == WebInputEvent::MouseMove) {
     if (mouse_move_pending_) {
       if (!next_mouse_move_.get()) {
         next_mouse_move_.reset(new WebMouseEvent(mouse_event));
@@ skipping 14 matching lines @@
 
   ForwardInputEvent(mouse_event, sizeof(WebMouseEvent), false);
 }
 
 void RenderWidgetHost::OnMouseActivate() {
 }
 
 void RenderWidgetHost::ForwardWheelEvent(
     const WebMouseWheelEvent& wheel_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardWheelEvent");
-  if (ignore_input_events_ || process_->ignore_input_events())
+  if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   // If there's already a mouse wheel event waiting to be sent to the renderer,
   // add the new deltas to that event. Not doing so (e.g., by dropping the old
   // event, as for mouse moves) results in very slow scrolling on the Mac (on
   // which many, very small wheel events are sent).
   if (mouse_wheel_pending_) {
     if (coalesced_mouse_wheel_events_.empty() ||
         !ShouldCoalesceMouseWheelEvents(coalesced_mouse_wheel_events_.back(),
                                         wheel_event)) {
@@ skipping 14 matching lines @@
 
   HISTOGRAM_COUNTS_100("MPArch.RWH_WheelQueueSize",
                        coalesced_mouse_wheel_events_.size());
 
   ForwardInputEvent(wheel_event, sizeof(WebMouseWheelEvent), false);
 }
 
 void RenderWidgetHost::ForwardGestureEvent(
     const WebKit::WebGestureEvent& gesture_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardWheelEvent");
-  if (ignore_input_events_ || process_->ignore_input_events())
+  if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   ForwardInputEvent(gesture_event, sizeof(WebGestureEvent), false);
 }
 
 void RenderWidgetHost::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardKeyboardEvent");
-  if (ignore_input_events_ || process_->ignore_input_events())
+  if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   if (key_event.type == WebKeyboardEvent::Char &&
       (key_event.windowsKeyCode == ui::VKEY_RETURN ||
        key_event.windowsKeyCode == ui::VKEY_SPACE)) {
     OnUserGesture();
   }
 
   // Double check the type to make sure caller hasn't sent us nonsense that
   // will mess up our key queue.
@@ skipping 45 matching lines @@
 }
 
 void RenderWidgetHost::ForwardInputEvent(const WebInputEvent& input_event,
                                          int event_size,
                                          bool is_keyboard_shortcut) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardInputEvent");
 
   if (!process_->HasConnection())
     return;
 
-  DCHECK(!process_->ignore_input_events());
+  DCHECK(!process_->IgnoreInputEvents());
 
   IPC::Message* message = new ViewMsg_HandleInputEvent(routing_id_);
   message->WriteData(
       reinterpret_cast<const char*>(&input_event), event_size);
   // |is_keyboard_shortcut| only makes sense for RawKeyDown events.
   if (input_event.type == WebInputEvent::RawKeyDown)
     message->WriteBool(is_keyboard_shortcut);
   input_event_start_time_ = TimeTicks::Now();
   Send(message);
 
   // Any non-wheel input event cancels pending wheel events.
   if (input_event.type != WebInputEvent::MouseWheel)
     coalesced_mouse_wheel_events_.clear();
 
   // Any input event cancels a pending mouse move event. Note that
   // |next_mouse_move_| possibly owns |input_event|, so don't use |input_event|
   // after this line.
   next_mouse_move_.reset();
 
   StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kHungRendererDelayMs));
 }
 
 void RenderWidgetHost::ForwardTouchEvent(
     const WebKit::WebTouchEvent& touch_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardTouchEvent");
-  if (ignore_input_events_ || process_->ignore_input_events())
+  if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   if (touch_event.type == WebInputEvent::TouchMove &&
       touch_move_pending_) {
     touch_event_is_queued_ = true;
     queued_touch_event_ = touch_event;
     return;
   }
 
   if (touch_event.type == WebInputEvent::TouchMove)
@@ skipping 737 matching lines @@
     pending_mouse_lock_request_ = false;
     if (!view_ || !view_->HasFocus()|| !view_->LockMouse()) {
       Send(new ViewMsg_LockMouse_ACK(routing_id_, false));
       return false;
     } else {
       Send(new ViewMsg_LockMouse_ACK(routing_id_, true));
       return true;
     }
   }
 }