Move more platform-specific stuff from WebContents to the view....

chrome/browser/render_view_host.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/render_view_host.h"
 
 #include <string>
 #include <vector>
 
 #include "base/string_util.h"
@@ skipping 936 matching lines @@
 void RenderViewHost::OnMsgDidDownloadImage(
     int id,
     const GURL& image_url,
     bool errored,
     const SkBitmap& image) {
   delegate_->DidDownloadImage(this, id, image_url, errored, image);
 }
 
 void RenderViewHost::OnMsgContextMenu(
     const ViewHostMsg_ContextMenu_Params& 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.
   ViewHostMsg_ContextMenu_Params validated_params(params);
   const int renderer_id = process()->host_id();
   RendererSecurityPolicy* policy = RendererSecurityPolicy::GetInstance();
 
   FilterURL(policy, renderer_id, &validated_params.link_url);
   FilterURL(policy, renderer_id, &validated_params.image_url);
   FilterURL(policy, renderer_id, &validated_params.page_url);
   FilterURL(policy, renderer_id, &validated_params.frame_url);
 
-  delegate_->ShowContextMenu(validated_params);
+  view->ShowContextMenu(validated_params);
 }
 
 void RenderViewHost::OnMsgOpenURL(const GURL& url,
                                   WindowOpenDisposition disposition) {
   GURL validated_url(url);
   FilterURL(RendererSecurityPolicy::GetInstance(),
             process()->host_id(), &validated_url);
 
   delegate_->RequestOpenURL(validated_url, disposition);
 }
@@ skipping 68 matching lines @@
   delegate_->ShowModalHTMLDialog(url, width, height, json_arguments, reply_msg);
 }
 
 void RenderViewHost::OnMsgPasswordFormsSeen(
     const std::vector<PasswordForm>& forms) {
   delegate_->PasswordFormsSeen(forms);
 }
 
 void RenderViewHost::OnMsgStartDragging(
     const WebDropData& drop_data) {
-  delegate_->StartDragging(drop_data);
+  RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
+  if (view)
+    view->StartDragging(drop_data);
 }
 
 void RenderViewHost::OnUpdateDragCursor(bool is_drop_target) {
-  delegate_->UpdateDragCursor(is_drop_target);
+  RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
+  if (view)
+    view->UpdateDragCursor(is_drop_target);
 }
 
 void RenderViewHost::OnTakeFocus(bool reverse) {
-  delegate_->TakeFocus(reverse);
+  RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
+  if (view)
+    view->TakeFocus(reverse);
 }
 
 void RenderViewHost::OnMsgPageHasOSDD(int32 page_id, const GURL& doc_url,
                                       bool autodetected) {
   delegate_->PageHasOSDD(this, page_id, doc_url, autodetected);
 }
 
 void RenderViewHost::OnMsgInspectElementReply(int num_resources) {
   delegate_->InspectElementReply(num_resources);
 }
@@ skipping 23 matching lines @@
     debugger_attached_ = true;
     g_browser_process->debugger_wrapper()->OnDebugAttach();
   }
 }
 
 void RenderViewHost::OnUserMetricsRecordAction(const std::wstring& action) {
   UserMetrics::RecordComputedAction(action.c_str(), process_->profile());
 }
 
 void RenderViewHost::UnhandledInputEvent(const WebInputEvent& event) {
-  if ((event.type == WebInputEvent::KEY_DOWN) ||
-      (event.type == WebInputEvent::CHAR))
-    delegate_->HandleKeyboardEvent(
-        static_cast<const WebKeyboardEvent&>(event));
+  RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
+  if (view) {
+    // TODO(brettw) why do we have to filter these types of events here. Can't
+    // the renderer just send us the ones we care abount, or maybe the view
+    // should be able to decide which ones it wants or not?
+    if ((event.type == WebInputEvent::KEY_DOWN) ||
+        (event.type == WebInputEvent::CHAR)) {
+      view->HandleKeyboardEvent(
+          static_cast<const WebKeyboardEvent&>(event));
+    }
+  }
 }
 
 void RenderViewHost::ForwardKeyboardEvent(const WebKeyboardEvent& key_event) {
   if (key_event.type == WebKeyboardEvent::CHAR &&
       (key_event.key_data == '\n' || key_event.key_data == ' ')) {
     delegate_->OnEnterOrSpace();
   }
   RenderWidgetHost::ForwardKeyboardEvent(key_event);
 }
 
@@ skipping 93 matching lines @@
                                         event_name,
                                         event_arg));
 }
 #endif
 
 void RenderViewHost::ForwardMessageFromExternalHost(
     const std::string& target, const std::string& message) {
   Send(new ViewMsg_HandleMessageFromExternalHost(routing_id_, target, message));
 }