Extract minimal RenderViewHost interface for embedders, leaving

content/browser/renderer_host/render_widget_host_view_mac.mm

 // 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_view_mac.h"
 
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 213 matching lines @@
 // static
 void content::RenderWidgetHostViewPort::GetDefaultScreenInfo(
     WebKit::WebScreenInfo* results) {
   *results = WebKit::WebScreenInfoFactory::screenInfo(NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewMac, public:
 
 RenderWidgetHostViewMac::RenderWidgetHostViewMac(RenderWidgetHost* widget)
-    : about_to_validate_and_paint_(false),
+    : render_widget_host_(RenderWidgetHostImpl::From(widget)),
+      about_to_validate_and_paint_(false),
       call_set_needs_display_in_rect_pending_(false),
       last_frame_was_accelerated_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       can_compose_inline_(true),
       is_loading_(false),
       is_hidden_(false),
       weak_factory_(this),
       accelerated_compositing_active_(false),
       needs_gpu_visibility_update_after_repaint_(false),
       compositing_surface_(gfx::kNullPluginWindow) {
-  render_widget_host_ = static_cast<RenderWidgetHostImpl*>(widget);
-
   // |cocoa_view_| owns us and we will be deleted when |cocoa_view_|
   // goes away.  Since we autorelease it, our caller must put
   // |GetNativeView()| into the view hierarchy right after calling us.
   cocoa_view_ = [[[RenderWidgetHostViewCocoa alloc]
                   initWithRenderWidgetHostViewMac:this] autorelease];
   render_widget_host_->SetView(this);
 }
 
 RenderWidgetHostViewMac::~RenderWidgetHostViewMac() {
   UnlockMouse();
@@ skipping 507 matching lines @@
   if (event.type == WebInputEvent::RawKeyDown &&
       [event.os_event type] == NSKeyDown)
     return [cocoa_view_ postProcessEventForPluginIme:event.os_event];
   return false;
 }
 
 void RenderWidgetHostViewMac::PluginImeCompositionCompleted(
     const string16& text, int plugin_id) {
   if (render_widget_host_) {
     render_widget_host_->Send(new ViewMsg_PluginImeCompositionCompleted(
-        render_widget_host_->routing_id(), text, plugin_id));
+        render_widget_host_->GetRoutingID(), text, plugin_id));
   }
 }
 
 gfx::PluginWindowHandle
 RenderWidgetHostViewMac::AllocateFakePluginWindowHandle(bool opaque,
                                                         bool root) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // |render_widget_host_| is set to NULL when |RWHVMac::Destroy()| has
   // completed. If |AllocateFakePluginWindowHandle()| is called after that,
@@ skipping 177 matching lines @@
   TRACE_EVENT0("renderer_host",
       "RenderWidgetHostViewMac::HandleDelayedGpuViewHiding");
   if (needs_gpu_visibility_update_after_repaint_) {
     UpdateRootGpuViewVisibility(false);
     needs_gpu_visibility_update_after_repaint_ = false;
   }
 }
 
 void RenderWidgetHostViewMac::OnAcceleratedCompositingStateChange() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  bool activated =
-      GetRenderWidgetHostImpl()->is_accelerated_compositing_active();
+  bool activated = RenderWidgetHostImpl::From(
+      GetRenderWidgetHost())->is_accelerated_compositing_active();
   bool changed = accelerated_compositing_active_ != activated;
   accelerated_compositing_active_ = activated;
   if (!changed)
     return;
 
   TRACE_EVENT1("renderer_host",
       "RenderWidgetHostViewMac::OnAcceleratedCompositingStateChange",
       "active", accelerated_compositing_active_);
   if (accelerated_compositing_active_) {
     UpdateRootGpuViewVisibility(accelerated_compositing_active_);
@@ skipping 115 matching lines @@
     SetTextInputActive(active);
   if (!active) {
     [cocoa_view_ setPluginImeActive:NO];
     UnlockMouse();
   }
 }
 
 void RenderWidgetHostViewMac::SetWindowVisibility(bool visible) {
   if (render_widget_host_) {
     render_widget_host_->Send(new ViewMsg_SetWindowVisibility(
-        render_widget_host_->routing_id(), visible));
+        render_widget_host_->GetRoutingID(), visible));
   }
 }
 
 void RenderWidgetHostViewMac::WindowFrameChanged() {
   if (render_widget_host_) {
     render_widget_host_->Send(new ViewMsg_WindowFrameChanged(
-        render_widget_host_->routing_id(), GetRootWindowBounds(),
+        render_widget_host_->GetRoutingID(), GetRootWindowBounds(),
         GetViewBounds()));
   }
 }
 
 void RenderWidgetHostViewMac::SetBackground(const SkBitmap& background) {
   content::RenderWidgetHostViewBase::SetBackground(background);
   if (render_widget_host_)
     render_widget_host_->Send(new ViewMsg_SetBackground(
-        render_widget_host_->routing_id(), background));
+        render_widget_host_->GetRoutingID(), background));
 }
 
 void RenderWidgetHostViewMac::OnAccessibilityNotifications(
     const std::vector<AccessibilityHostMsg_NotificationParams>& params) {
   if (!GetBrowserAccessibilityManager()) {
     SetBrowserAccessibilityManager(
         BrowserAccessibilityManager::CreateEmptyDocument(
             cocoa_view_, static_cast<WebAccessibility::State>(0), NULL));
   }
   GetBrowserAccessibilityManager()->OnAccessibilityNotifications(params);
@@ skipping 403 matching lines @@
     // enqueued edit commands, then in order to let webkit handle them
     // correctly, we need to send the real key event and corresponding edit
     // commands after processing the input method result.
     // We shouldn't do this if a new marked text was set by the input method,
     // otherwise the new marked text might be cancelled by webkit.
     if (hasEditCommands_ && !hasMarkedText_)
       delayEventUntilAfterImeCompostion = YES;
   } else {
     if (!editCommands_.empty()) {
       widgetHost->Send(new ViewMsg_SetEditCommandsForNextKeyEvent(
-          widgetHost->routing_id(), editCommands_));
+          widgetHost->GetRoutingID(), editCommands_));
     }
     widgetHost->ForwardKeyboardEvent(event);
   }
 
   // Calling ForwardKeyboardEvent() could have destroyed the widget. When the
   // widget was destroyed, |renderWidgetHostView_->render_widget_host_| will
   // be set to NULL. So we check it here and return immediately if it's NULL.
   if (!renderWidgetHostView_->render_widget_host_)
     return;
 
@@ skipping 45 matching lines @@
     NativeWebKeyboardEvent fakeEvent = event;
     fakeEvent.type = WebKit::WebInputEvent::KeyUp;
     fakeEvent.skip_in_browser = true;
     widgetHost->ForwardKeyboardEvent(fakeEvent);
     // Not checking |renderWidgetHostView_->render_widget_host_| here because
     // a key event with |skip_in_browser| == true won't be handled by browser,
     // thus it won't destroy the widget.
 
     if (!editCommands_.empty()) {
       widgetHost->Send(new ViewMsg_SetEditCommandsForNextKeyEvent(
-        widgetHost->routing_id(), editCommands_));
+          widgetHost->GetRoutingID(), editCommands_));
     }
     widgetHost->ForwardKeyboardEvent(event);
 
     // Calling ForwardKeyboardEvent() could have destroyed the widget. When the
     // widget was destroyed, |renderWidgetHostView_->render_widget_host_| will
     // be set to NULL. So we check it here and return immediately if it's NULL.
     if (!renderWidgetHostView_->render_widget_host_)
       return;
   }
 
@@ skipping 407 matching lines @@
       if (focused_item_cocoa)
         return focused_item_cocoa;
     }
   }
   return [super accessibilityFocusedUIElement];
 }
 
 - (void)doDefaultAction:(int32)accessibilityObjectId {
   RenderWidgetHostImpl* rwh = renderWidgetHostView_->render_widget_host_;
   rwh->Send(new AccessibilityMsg_DoDefaultAction(
-      rwh->routing_id(), accessibilityObjectId));
+      rwh->GetRoutingID(), accessibilityObjectId));
 }
 
 // Convert a web accessibility's location in web coordinates into a cocoa
 // screen coordinate.
 - (NSPoint)accessibilityPointInScreen:
     (BrowserAccessibilityCocoa*)accessibility {
   NSPoint origin = [accessibility origin];
   NSSize size = [[accessibility size] sizeValue];
   origin.y = NSHeight([self bounds]) - origin.y;
   NSPoint originInWindow = [self convertPoint:origin toView:nil];
   NSPoint originInScreen = [[self window] convertBaseToScreen:originInWindow];
   originInScreen.y = originInScreen.y - size.height;
   return originInScreen;
 }
 
 - (void)setAccessibilityFocus:(BOOL)focus
               accessibilityId:(int32)accessibilityObjectId {
   if (focus) {
     RenderWidgetHostImpl* rwh = renderWidgetHostView_->render_widget_host_;
     rwh->Send(new AccessibilityMsg_SetFocus(
-        rwh->routing_id(), accessibilityObjectId));
+        rwh->GetRoutingID(), accessibilityObjectId));
   }
 }
 
 - (void)performShowMenuAction:(BrowserAccessibilityCocoa*)accessibility {
   // Performs a right click copying WebKit's
   // accessibilityPerformShowMenuAction.
   NSPoint location = [self accessibilityPointInScreen:accessibility];
   NSSize size = [[accessibility size] sizeValue];
   location = [[self window] convertScreenToBase:location];
   location.x += size.width/2;
@@ skipping 430 matching lines @@
   // it here.
   if (handlingKeyDown_) {
     hasEditCommands_ = YES;
     // We ignore commands that insert characters, because this was causing
     // strange behavior (e.g. tab always inserted a tab rather than moving to
     // the next field on the page).
     if (!StartsWithASCII(command, "insert", false))
       editCommands_.push_back(EditCommand(command, ""));
   } else {
     RenderWidgetHostImpl* rwh = renderWidgetHostView_->render_widget_host_;
-    rwh->Send(new ViewMsg_ExecuteEditCommand(rwh->routing_id(), command, ""));
+    rwh->Send(new ViewMsg_ExecuteEditCommand(rwh->GetRoutingID(), command, ""));
   }
 }
 
 - (void)insertText:(id)string replacementRange:(NSRange)replacementRange {
   // An input method has characters to be inserted.
   // Same as Linux, Mac calls this method not only:
   // * when an input method finishs composing text, but also;
   // * when we type an ASCII character (without using input methods).
   // When we aren't using input methods, we should send the given character as
   // a Char event so it is dispatched to an onkeypress() event handler of
@@ skipping 52 matching lines @@
     event.button = WebMouseEvent::ButtonLeft;
     if (renderWidgetHostView_->render_widget_host_)
       renderWidgetHostView_->render_widget_host_->ForwardMouseEvent(event);
 
     hasOpenMouseDown_ = NO;
   }
 }
 
 - (void)undo:(id)sender {
   if (renderWidgetHostView_->render_widget_host_->IsRenderView()) {
-    static_cast<RenderViewHost*>(renderWidgetHostView_->render_widget_host_)->
-        Undo();
+    static_cast<RenderViewHostImpl*>(
+        renderWidgetHostView_->render_widget_host_)->Undo();
   }
 }
 
 - (void)redo:(id)sender {
   if (renderWidgetHostView_->render_widget_host_->IsRenderView()) {
-    static_cast<RenderViewHost*>(renderWidgetHostView_->render_widget_host_)->
-        Redo();
+    static_cast<RenderViewHostImpl*>(
+        renderWidgetHostView_->render_widget_host_)->Redo();
   }
 }
 
 - (void)cut:(id)sender {
   if (renderWidgetHostView_->render_widget_host_->IsRenderView()) {
-    static_cast<RenderViewHost*>(renderWidgetHostView_->render_widget_host_)->
-        Cut();
+    static_cast<RenderViewHostImpl*>(
+        renderWidgetHostView_->render_widget_host_)->Cut();
   }
 }
 
 - (void)copy:(id)sender {
   if (renderWidgetHostView_->render_widget_host_->IsRenderView()) {
-    static_cast<RenderViewHost*>(renderWidgetHostView_->render_widget_host_)->
-        Copy();
+    static_cast<RenderViewHostImpl*>(
+        renderWidgetHostView_->render_widget_host_)->Copy();
   }
 }
 
 - (void)copyToFindPboard:(id)sender {
   if (renderWidgetHostView_->render_widget_host_->IsRenderView()) {
-    static_cast<RenderViewHost*>(renderWidgetHostView_->render_widget_host_)->
-        CopyToFindPboard();
+    static_cast<RenderViewHostImpl*>(
+        renderWidgetHostView_->render_widget_host_)->CopyToFindPboard();
   }
 }
 
 - (void)paste:(id)sender {
   if (renderWidgetHostView_->render_widget_host_->IsRenderView()) {
-    static_cast<RenderViewHost*>(renderWidgetHostView_->render_widget_host_)->
-        Paste();
+    static_cast<RenderViewHostImpl*>(
+        renderWidgetHostView_->render_widget_host_)->Paste();
   }
 }
 
 - (void)pasteAndMatchStyle:(id)sender {
   if (renderWidgetHostView_->render_widget_host_->IsRenderView()) {
-    static_cast<RenderViewHost*>(renderWidgetHostView_->render_widget_host_)->
-        PasteAndMatchStyle();
+    static_cast<RenderViewHostImpl*>(
+        renderWidgetHostView_->render_widget_host_)->PasteAndMatchStyle();
   }
 }
 
 - (void)cancelComposition {
   if (!hasMarkedText_)
     return;
 
   // Cancel the ongoing composition. [NSInputManager markedTextAbandoned:]
   // doesn't call any NSTextInput functions, such as setMarkedText or
   // insertText. So, we need to send an IPC message to a renderer so it can
@@ skipping 85 matching lines @@
     requestor = [super validRequestorForSendType:sendType
                                       returnType:returnType];
   }
   return requestor;
 }
 
 - (void)viewWillStartLiveResize {
   [super viewWillStartLiveResize];
   RenderWidgetHostImpl* widget = renderWidgetHostView_->render_widget_host_;
   if (widget)
-    widget->Send(new ViewMsg_SetInLiveResize(widget->routing_id(), true));
+    widget->Send(new ViewMsg_SetInLiveResize(widget->GetRoutingID(), true));
 }
 
 - (void)viewDidEndLiveResize {
   [super viewDidEndLiveResize];
   RenderWidgetHostImpl* widget = renderWidgetHostView_->render_widget_host_;
   if (widget)
-    widget->Send(new ViewMsg_SetInLiveResize(widget->routing_id(), false));
+    widget->Send(new ViewMsg_SetInLiveResize(widget->GetRoutingID(), false));
 }
 
 @end
 
 //
 // Supporting application services
 //
 @implementation RenderWidgetHostViewCocoa(NSServicesRequests)
 
 - (BOOL)writeSelectionToPasteboard:(NSPasteboard*)pboard
@@ skipping 13 matching lines @@
   if (!string) return NO;
 
   // If the user is currently using an IME, confirm the IME input,
   // and then insert the text from the service, the same as TextEdit and Safari.
   [self confirmComposition];
   [self insertText:string];
   return YES;
 }
 
 @end