Part 1 of merging Extensions and DOMUI

chrome/browser/tab_contents/tab_contents.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/tab_contents/tab_contents.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/file_version_info.h"
 #include "base/process_util.h"
@@ skipping 479 matching lines @@
 const std::wstring TabContents::GetDefaultTitle() const {
   return l10n_util::GetString(IDS_DEFAULT_TAB_TITLE);
 }
 
 bool TabContents::ShouldDisplayURL() {
   // Don't hide the url in view source mode.
   NavigationEntry* entry = controller_.GetActiveEntry();
   if (entry && entry->IsViewSourceMode())
     return true;
 
-  // Hide the URL in chrome-extension://.
-  if (GetURL().SchemeIs(chrome::kExtensionScheme))
-    return false;
-
   DOMUI* dom_ui = GetDOMUIForCurrentState();
   if (dom_ui)
     return !dom_ui->should_hide_url();
   return true;
 }
 
 SkBitmap TabContents::GetFavIcon() const {
   // Like GetTitle(), we also want to use the favicon for the last committed
   // entry rather than a pending navigation entry.
   NavigationEntry* entry = controller_.GetTransientEntry();
@@ skipping 982 matching lines @@
   return save_package_.get();  // May be NULL, but we can return NULL.
 }
 
 RendererPreferences TabContents::GetRendererPrefs() const {
   if (delegate())
     return delegate()->GetRendererPrefs();
   else
     return RendererPreferences();
 }
 
-ExtensionFunctionDispatcher* TabContents::CreateExtensionFunctionDispatcher(
-    RenderViewHost* render_view_host,
-    const std::string& extension_id) {
-  return delegate()->CreateExtensionFunctionDispatcher(render_view_host,
-      extension_id);
-}
-
 TabContents* TabContents::GetAsTabContents() {
   return this;
 }
 
 void TabContents::RenderViewCreated(RenderViewHost* render_view_host) {
   NavigationEntry* entry = controller_.GetActiveEntry();
   if (!entry)
     return;
 
   // When we're creating views, we're still doing initial setup, so we always
@@ skipping 334 matching lines @@
 
 void TabContents::DomOperationResponse(const std::string& json_string,
                                        int automation_id) {
   DomOperationNotificationDetails details(json_string, automation_id);
   NotificationService::current()->Notify(
       NotificationType::DOM_OPERATION_RESPONSE, Source<TabContents>(this),
       Details<DomOperationNotificationDetails>(&details));
 }
 
 void TabContents::ProcessDOMUIMessage(const std::string& message,
-                                      const std::string& content) {
+                                      const std::string& content,
+                                      int request_id,
+                                      bool has_callback) {
   if (!render_manager_.dom_ui()) {
     // We shouldn't get a DOM UI message when we haven't enabled the DOM UI.
     // Because the renderer might be owned and sending random messages, we need
     // to ignore these inproper ones.
     NOTREACHED();
     return;
   }
-  render_manager_.dom_ui()->ProcessDOMUIMessage(message, content);
+  render_manager_.dom_ui()->ProcessDOMUIMessage(message, content, request_id,
+                                                has_callback);
 }
 
 void TabContents::DocumentLoadedInFrame() {
   controller_.DocumentLoadedInFrame();
 }
 
 void TabContents::ProcessExternalHostMessage(const std::string& message,
                                              const std::string& origin,
                                              const std::string& target) {
   if (delegate())
@@ skipping 387 matching lines @@
   return DOMUIFactory::CreateDOMUIForURL(this, url);
 }
 
 NavigationEntry*
 TabContents::GetLastCommittedNavigationEntryForRenderManager() {
   return controller_.GetLastCommittedEntry();
 }
 
 bool TabContents::CreateRenderViewForRenderManager(
     RenderViewHost* render_view_host) {
-  // When we're running a DOM UI, the RenderViewHost needs to be put in DOM UI
-  // mode before CreateRenderView is called. When we're asked to create a
-  // RenderView, that means it's for the pending entry, so we have to use the
-  // pending DOM UI.
+  // If the pending navigation is to a DOMUI, tell the RenderView about any
+  // bindings it will need enabled.
   if (render_manager_.pending_dom_ui())
-    render_view_host->AllowDOMUIBindings();
-
-  // Ditto for extension bindings.
-  if (controller().pending_entry()->url().SchemeIs(chrome::kExtensionScheme))
-    render_view_host->AllowExtensionBindings();
+    render_view_host->AllowBindings(
+        render_manager_.pending_dom_ui()->bindings());
 
   RenderWidgetHostView* rwh_view = view_->CreateViewForWidget(render_view_host);
   if (!render_view_host->CreateRenderView())
     return false;
 
   // Now that the RenderView has been created, we need to tell it its size.
   rwh_view->SetSize(view_->GetContainerSize());
 
   UpdateMaxPageIDIfNecessary(render_view_host->site_instance(),
                              render_view_host);
@@ skipping 40 matching lines @@
       NavigationController::LoadCommittedDetails& committed_details =
           *(Details<NavigationController::LoadCommittedDetails>(details).ptr());
       ExpireInfoBars(committed_details);
       break;
     }
 
     default:
       NOTREACHED();
   }
 }