Part 1 of merging Extensions and DOMUI

chrome/browser/renderer_host/render_view_host.cc

 // Copyright (c) 2009 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/renderer_host/render_view_host.h"
 
 #include <string>
 #include <vector>
 
 #include "app/resource_bundle.h"
@@ skipping 24 matching lines @@
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "webkit/api/public/WebFindOptions.h"
 #include "webkit/glue/autofill_form.h"
 
 #if defined(OS_WIN)
 // TODO(port): accessibility not yet implemented. See http://crbug.com/8288.
 #include "chrome/browser/browser_accessibility_manager.h"
 #endif
 
 using base::TimeDelta;
-using webkit_glue::AutofillForm;
 using webkit_glue::PasswordFormDomManager;
 using WebKit::WebConsoleMessage;
 using WebKit::WebFindOptions;
 using WebKit::WebInputEvent;
 
 namespace {
 
 void FilterURL(ChildProcessSecurityPolicy* policy, int renderer_id, GURL* url) {
   if (!url->is_valid())
     return;  // We don't need to block invalid URLs.
@@ skipping 507 matching lines @@
       routing_id(),
       gfx::Point(client_x, client_y),
       gfx::Point(screen_x, screen_y),
       false));
 }
 
 void RenderViewHost::DragSourceSystemDragEnded() {
   Send(new ViewMsg_DragSourceSystemDragEnded(routing_id()));
 }
 
-void RenderViewHost::AllowDomAutomationBindings() {
+void RenderViewHost::AllowBindings(int bindings_flags) {
   DCHECK(!renderer_initialized_);
-  enabled_bindings_ |= BindingsPolicy::DOM_AUTOMATION;
-}
-
-void RenderViewHost::AllowExternalHostBindings() {
-  DCHECK(!renderer_initialized_);
-  enabled_bindings_ |= BindingsPolicy::EXTERNAL_HOST;
-}
-
-void RenderViewHost::AllowDOMUIBindings() {
-  DCHECK(!renderer_initialized_);
-  enabled_bindings_ |= BindingsPolicy::DOM_UI;
-}
-
-void RenderViewHost::AllowExtensionBindings() {
-  DCHECK(!renderer_initialized_);
-  enabled_bindings_ |= BindingsPolicy::EXTENSION;
+  enabled_bindings_ |= bindings_flags;
 }
 
 void RenderViewHost::SetDOMUIProperty(const std::string& name,
                                       const std::string& value) {
   DCHECK(BindingsPolicy::is_dom_ui_enabled(enabled_bindings_));
   Send(new ViewMsg_SetDOMUIProperty(routing_id(), name, value));
 }
 
 void RenderViewHost::GotFocus() {
   RenderWidgetHost::GotFocus();  // Notifies the renderer it got focus.
@@ skipping 275 matching lines @@
   FilterURL(policy, renderer_id, &validated_params.url);
   FilterURL(policy, renderer_id, &validated_params.referrer);
   for (std::vector<GURL>::iterator it(validated_params.redirects.begin());
       it != validated_params.redirects.end(); ++it) {
     FilterURL(policy, renderer_id, &(*it));
   }
   FilterURL(policy, renderer_id, &validated_params.searchable_form_url);
   FilterURL(policy, renderer_id, &validated_params.password_form.origin);
   FilterURL(policy, renderer_id, &validated_params.password_form.action);
 
-  if (PageTransition::IsMainFrame(validated_params.transition)) {
-    ExtensionFunctionDispatcher* new_efd = NULL;
-    if (validated_params.url.SchemeIs(chrome::kExtensionScheme)) {
-      new_efd = delegate()->CreateExtensionFunctionDispatcher(this,
-          validated_params.url.host());
-    }
-    extension_function_dispatcher_.reset(new_efd);
-  }
-
   delegate_->DidNavigate(this, validated_params);
 
   UpdateBackForwardListCount();
 }
 
 void RenderViewHost::OnMsgUpdateState(int32 page_id,
                                       const std::string& state) {
   delegate_->UpdateState(this, page_id, state);
 }
 
@@ skipping 159 matching lines @@
   delegate_->DomOperationResponse(json_string, automation_id);
 }
 
 void RenderViewHost::OnMsgDOMUISend(
     const std::string& message, const std::string& content) {
   if (!ChildProcessSecurityPolicy::GetInstance()->
           HasDOMUIBindings(process()->pid())) {
     NOTREACHED() << "Blocked unauthorized use of DOMUIBindings.";
     return;
   }
-  delegate_->ProcessDOMUIMessage(message, content);
+
+  // DOMUI doesn't use these values yet.
+  // TODO(aa): When DOMUI is ported to ExtensionFunctionDispatcher, send real
+  // values here.
+  const int kRequestId = -1;
+  const bool kHasCallback = false;
+
+  delegate_->ProcessDOMUIMessage(message, content, kRequestId, kHasCallback);
 }
 
 void RenderViewHost::OnMsgForwardMessageToExternalHost(
     const std::string& message, const std::string& origin,
     const std::string& target) {
   delegate_->ProcessExternalHostMessage(message, origin, target);
 }
 
 void RenderViewHost::OnMsgDocumentLoadedInFrame() {
   delegate_->DocumentLoadedInFrame();
@@ skipping 63 matching lines @@
     modal_dialog_event_->Signal();
   delegate_->ShowModalHTMLDialog(url, width, height, json_arguments, reply_msg);
 }
 
 void RenderViewHost::OnMsgPasswordFormsSeen(
     const std::vector<webkit_glue::PasswordForm>& forms) {
   delegate_->PasswordFormsSeen(forms);
 }
 
 void RenderViewHost::OnMsgAutofillFormSubmitted(
-    const AutofillForm& form) {
+    const webkit_glue::AutofillForm& form) {
   delegate_->AutofillFormSubmitted(form);
 }
 
 void RenderViewHost::OnMsgStartDragging(
     const WebDropData& drop_data) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (view)
     view->StartDragging(drop_data);
 }
 
@@ skipping 192 matching lines @@
 void RenderViewHost::OnExtensionRequest(const std::string& name,
                                         const std::string& args,
                                         int request_id,
                                         bool has_callback) {
   if (!ChildProcessSecurityPolicy::GetInstance()->
           HasExtensionBindings(process()->pid())) {
     NOTREACHED() << "Blocked unauthorized use of extension bindings.";
     return;
   }
 
-  DCHECK(extension_function_dispatcher_.get());
-  extension_function_dispatcher_->HandleRequest(name, args, request_id,
-      has_callback);
+  delegate_->ProcessDOMUIMessage(name, args, request_id, has_callback);
 }
 
 void RenderViewHost::SendExtensionResponse(int request_id, bool success,
                                            const std::string& response,
                                            const std::string& error) {
   Send(new ViewMsg_ExtensionResponse(routing_id(), request_id, success,
       response, error));
 }
 
 void RenderViewHost::OnExtensionPostMessage(
     int port_id, const std::string& message) {
   URLRequestContext* context = process()->profile()->GetRequestContext();
   ExtensionMessageService::GetInstance(context)->
       PostMessageFromRenderer(port_id, message);
 }
 
 void RenderViewHost::OnAccessibilityFocusChange(int acc_obj_id) {
 #if defined(OS_WIN)
   BrowserAccessibilityManager::GetInstance()->
       ChangeAccessibilityFocus(acc_obj_id, process()->pid(), routing_id());
 #else
   // TODO(port): accessibility not yet implemented. See http://crbug.com/8288.
 #endif
 }
 
 void RenderViewHost::OnCSSInserted() {
   delegate_->DidInsertCSS();
 }