Separate RenderViewHost from RenderWidgetHost, part 5: move calls to the RenderWidgetHostDelegate.

content/browser/renderer_host/render_widget_host_impl.cc

 // Copyright (c) 2012 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_impl.h"
 
 #include <math.h>
 #include <set>
 #include <utility>
 
@@ skipping 547 matching lines @@
   // deal as RenderWidget::WasShown delays updating, so that the resize from
   // WasResized is usually processed before the renderer is painted.
   WasResized();
 }
 
 bool RenderWidgetHostImpl::GetResizeParams(
     ViewMsg_Resize_Params* resize_params) {
   *resize_params = ViewMsg_Resize_Params();
 
   GetWebScreenInfo(&resize_params->screen_info);
-  resize_params->resizer_rect = GetRootWindowResizerRect();
+  if (delegate_)
+    resize_params->resizer_rect = delegate_->GetRootWindowResizerRect(this);
 
   if (view_) {
     resize_params->new_size = view_->GetRequestedRendererSize();
     resize_params->physical_backing_size = view_->GetPhysicalBackingSize();
     resize_params->top_controls_height = view_->GetTopControlsHeight();
     resize_params->top_controls_shrink_blink_size =
         view_->DoTopControlsShrinkBlinkSize();
     resize_params->visible_viewport_size = view_->GetVisibleViewportSize();
     resize_params->is_fullscreen_granted = IsFullscreenGranted();
     resize_params->display_mode = GetDisplayMode();
@@ skipping 510 matching lines @@
     // Some keypresses that are accepted by the listener might have follow up
     // char events, which should be ignored.
     if (key_event.type == WebKeyboardEvent::RawKeyDown)
       suppress_next_char_events_ = true;
     return;
   }
 
   if (key_event.type == WebKeyboardEvent::Char &&
       (key_event.windowsKeyCode == ui::VKEY_RETURN ||
        key_event.windowsKeyCode == ui::VKEY_SPACE)) {
-    OnUserGesture();
+    if (delegate_)
+      delegate_->OnUserGesture(this);
   }
 
   // Double check the type to make sure caller hasn't sent us nonsense that
   // will mess up our key queue.
   if (!WebInputEvent::isKeyboardEventType(key_event.type))
     return;
 
   if (suppress_next_char_events_) {
     // If preceding RawKeyDown event was handled by the browser, then we need
     // suppress all Char events generated by it. Please note that, one
@@ skipping 250 matching lines @@
     bool keep_selection) {
   Send(new InputMsg_ImeConfirmComposition(
         GetRoutingID(), text, replacement_range, keep_selection));
 }
 
 void RenderWidgetHostImpl::ImeCancelComposition() {
   Send(new InputMsg_ImeSetComposition(GetRoutingID(), base::string16(),
             std::vector<blink::WebCompositionUnderline>(), 0, 0));
 }
 
-gfx::Rect RenderWidgetHostImpl::GetRootWindowResizerRect() const {
-  return gfx::Rect();
-}
-
-void RenderWidgetHostImpl::RequestToLockMouse(bool user_gesture,
-                                              bool last_unlocked_by_target) {
-  // Directly reject to lock the mouse. Subclass can override this method to
-  // decide whether to allow mouse lock or not.
-  GotResponseToLockMouseRequest(false);
-}
-
 void RenderWidgetHostImpl::RejectMouseLockOrUnlockIfNecessary() {
   DCHECK(!pending_mouse_lock_request_ || !IsMouseLocked());
   if (pending_mouse_lock_request_) {
     pending_mouse_lock_request_ = false;
     Send(new ViewMsg_LockMouse_ACK(routing_id_, false));
   } else if (IsMouseLocked()) {
     view_->UnlockMouse();
   }
 }
 
@@ skipping 34 matching lines @@
 
   delete this;
 }
 
 void RenderWidgetHostImpl::RendererIsUnresponsive() {
   NotificationService::current()->Notify(
       NOTIFICATION_RENDER_WIDGET_HOST_HANG,
       Source<RenderWidgetHost>(this),
       NotificationService::NoDetails());
   is_unresponsive_ = true;
-  NotifyRendererUnresponsive();
+  if (delegate_)
+    delegate_->RendererUnresponsive(this);
 }
 
 void RenderWidgetHostImpl::RendererIsResponsive() {
   if (is_unresponsive_) {
     is_unresponsive_ = false;
-    NotifyRendererResponsive();
+    if (delegate_)
+      delegate_->RendererResponsive(this);
   }
 }
 
 void RenderWidgetHostImpl::ClearDisplayedGraphics() {
   NotifyNewContentRenderingTimeoutForTesting();
   if (view_)
     view_->ClearCompositorFrame();
 }
 
 void RenderWidgetHostImpl::OnRenderProcessGone(int status, int exit_code) {
@@ skipping 277 matching lines @@
   if (IsMouseLocked()) {
     Send(new ViewMsg_LockMouse_ACK(routing_id_, true));
     return;
   }
 
   pending_mouse_lock_request_ = true;
   if (privileged && allow_privileged_mouse_lock_) {
     // Directly approve to lock the mouse.
     GotResponseToLockMouseRequest(true);
   } else {
-    RequestToLockMouse(user_gesture, last_unlocked_by_target);
+    if (delegate_) {
+      delegate_->RequestToLockMouse(this, user_gesture,
+                                    last_unlocked_by_target);
+      return;
+    }
+    // If there's no delegate, just reject it.
+    GotResponseToLockMouseRequest(false);
   }
 }
 
 void RenderWidgetHostImpl::OnUnlockMouse() {
   RejectMouseLockOrUnlockIfNecessary();
 }
 
 void RenderWidgetHostImpl::OnShowDisambiguationPopup(
     const gfx::Rect& rect_pixels,
     const gfx::Size& size,
@@ skipping 95 matching lines @@
   // events are being ignored in order to keep the renderer from getting
   // confused about how many touches are active.
   if (IgnoreInputEvents() && event.type != WebInputEvent::TouchCancel)
     return INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
 
   if (!process_->HasConnection())
     return INPUT_EVENT_ACK_STATE_UNKNOWN;
 
   if (event.type == WebInputEvent::MouseDown ||
       event.type == WebInputEvent::GestureTapDown) {
-    OnUserGesture();
+    if (delegate_)
+      delegate_->OnUserGesture(this);
   }
 
   if (delegate_) {
     if (event.type == WebInputEvent::MouseDown ||
         event.type == WebInputEvent::GestureTapDown ||
         event.type == WebInputEvent::RawKeyDown) {
       delegate_->OnUserInteraction(event.type);
     }
   }
 
@@ skipping 113 matching lines @@
 
 void RenderWidgetHostImpl::OnSyntheticGestureCompleted(
     SyntheticGesture::Result result) {
   Send(new InputMsg_SyntheticGestureCompleted(GetRoutingID()));
 }
 
 bool RenderWidgetHostImpl::IgnoreInputEvents() const {
   return ignore_input_events_ || process_->IgnoreInputEvents();
 }
 
-void RenderWidgetHostImpl::StartUserGesture() {
-  OnUserGesture();
-}
-
 void RenderWidgetHostImpl::SetBackgroundOpaque(bool opaque) {
   Send(new ViewMsg_SetBackgroundOpaque(GetRoutingID(), opaque));
 }
 
 void RenderWidgetHostImpl::SetEditCommandsForNextKeyEvent(
     const std::vector<EditCommand>& commands) {
   Send(new InputMsg_SetEditCommandsForNextKeyEvent(GetRoutingID(), commands));
 }
 
 void RenderWidgetHostImpl::ExecuteEditCommand(const std::string& command,
@@ skipping 60 matching lines @@
 
 void RenderWidgetHostImpl::DelayedAutoResized() {
   gfx::Size new_size = new_auto_size_;
   // Clear the new_auto_size_ since the empty value is used as a flag to
   // indicate that no callback is in progress (i.e. without this line
   // DelayedAutoResized will not get called again).
   new_auto_size_.SetSize(0, 0);
   if (!auto_resize_enabled_)
     return;
 
-  OnRenderAutoResized(new_size);
+  if (delegate_)
+    delegate_->ResizeDueToAutoResize(this, new_size);
 }
 
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
 void RenderWidgetHostImpl::FrameSwapped(const ui::LatencyInfo& latency_info) {
   ui::LatencyInfo::LatencyComponent window_snapshot_component;
   if (latency_info.FindLatency(ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT,
                                GetLatencyComponentId(),
@@ skipping 107 matching lines @@
 }
 
 #if defined(OS_WIN)
 gfx::NativeViewAccessible
     RenderWidgetHostImpl::GetParentNativeViewAccessible() {
   return delegate_ ? delegate_->GetParentNativeViewAccessible() : NULL;
 }
 #endif
 
 }  // namespace content