[DevTools] Move DevToolsClientHost functionality out of DevToolsFrontendHost.

chrome/browser/devtools/devtools_ui_bindings.cc

 // Copyright 2014 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/devtools/devtools_ui_bindings.h"
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 241 matching lines @@
 DevToolsUIBindings::FrontendWebContentsObserver::
     ~FrontendWebContentsObserver() {
 }
 
 void DevToolsUIBindings::FrontendWebContentsObserver::WebContentsDestroyed() {
   delete devtools_bindings_;
 }
 
 void DevToolsUIBindings::FrontendWebContentsObserver::RenderProcessGone(
     base::TerminationStatus status) {
+  switch (status) {
+    case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
+    case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
+    case base::TERMINATION_STATUS_PROCESS_CRASHED:
+      content::DevToolsManager::GetInstance()->ClientHostClosing(
+          devtools_bindings_);
+      break;
+    default:
+      break;
+  }
   devtools_bindings_->delegate_->RenderProcessGone();
 }
 
 void DevToolsUIBindings::FrontendWebContentsObserver::AboutToNavigateRenderView(
     content::RenderViewHost* render_view_host) {
   content::NavigationEntry* entry =
       web_contents()->GetController().GetActiveEntry();
-  if (devtools_bindings_->url_ == entry->GetURL())
-    content::DevToolsClientHost::SetupDevToolsFrontendClient(render_view_host);
-  else
+  if (devtools_bindings_->url_ != entry->GetURL())
     delete devtools_bindings_;
 }
 
 void DevToolsUIBindings::FrontendWebContentsObserver::
     DocumentOnLoadCompletedInMainFrame() {
   devtools_bindings_->DocumentOnLoadCompletedInMainFrame();
 }
 
 // DevToolsUIBindings ---------------------------------------------------------
 
@@ skipping 22 matching lines @@
     : profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())),
       web_contents_(web_contents),
       delegate_(new DefaultBindingsDelegate(web_contents_)),
       device_count_updates_enabled_(false),
       devices_updates_enabled_(false),
       url_(url),
       weak_factory_(this) {
   frontend_contents_observer_.reset(new FrontendWebContentsObserver(this));
   web_contents_->GetMutableRendererPrefs()->can_accept_load_drops = false;
 
-  frontend_host_.reset(content::DevToolsClientHost::CreateDevToolsFrontendHost(
+  frontend_host_.reset(content::DevToolsFrontendHost::Create(
       web_contents_, this));
   file_helper_.reset(new DevToolsFileHelper(web_contents_, profile_));
   file_system_indexer_ = new DevToolsFileSystemIndexer();
   extensions::ChromeExtensionWebContentsObserver::CreateForWebContents(
       web_contents_);
 
   web_contents_->GetController().LoadURL(
       url, content::Referrer(),
       content::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string());
 
   // Wipe out page icon so that the default application icon is used.
   content::NavigationEntry* entry =
       web_contents_->GetController().GetActiveEntry();
   entry->GetFavicon().image = gfx::Image();
   entry->GetFavicon().valid = true;
 
   // Register on-load actions.
   registrar_.Add(
       this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
       content::Source<ThemeService>(
           ThemeServiceFactory::GetForProfile(profile_)));
 
   embedder_message_dispatcher_.reset(
       DevToolsEmbedderMessageDispatcher::createForDevToolsFrontend(this));
 }
 
 DevToolsUIBindings::~DevToolsUIBindings() {
-  content::DevToolsManager::GetInstance()->ClientHostClosing(
-      frontend_host_.get());
+  content::DevToolsManager::GetInstance()->ClientHostClosing(this);
 
   for (IndexingJobsMap::const_iterator jobs_it(indexing_jobs_.begin());
        jobs_it != indexing_jobs_.end(); ++jobs_it) {
     jobs_it->second->Stop();
   }
   indexing_jobs_.clear();
   SetDeviceCountUpdatesEnabled(false);
   SetDevicesUpdatesEnabled(false);
 }
 
-void DevToolsUIBindings::InspectedContentsClosing() {
-  delegate_->InspectedContentsClosing();
-}
-
+// content::NotificationObserver overrides ------------------------------------
 void DevToolsUIBindings::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_BROWSER_THEME_CHANGED, type);
   UpdateTheme();
 }
 
-void DevToolsUIBindings::DispatchOnEmbedder(const std::string& message) {
+// content::DevToolsFrontendHost::Delegate implementation ---------------------
+bool DevToolsUIBindings::ShouldSetupDevToolsFrontendForUrl(const GURL& url) {
+  return url.SchemeIs(content::kChromeDevToolsScheme);

[pfeldman, 2014/07/31 11:47:25]

It seems like we can make this decision in content.

+}
+
+void DevToolsUIBindings::HandleMessageFromDevToolsFrontend(
+    const std::string& message) {
   std::string method;
   base::ListValue empty_params;
   base::ListValue* params = &empty_params;
 
   base::DictionaryValue* dict = NULL;
   scoped_ptr<base::Value> parsed_message(base::JSONReader::Read(message));
   if (!parsed_message ||
       !parsed_message->GetAsDictionary(&dict) ||
       !dict->GetString(kFrontendHostMethod, &method) ||
       (dict->HasKey(kFrontendHostParams) &&
           !dict->GetList(kFrontendHostParams, &params))) {
     LOG(ERROR) << "Invalid message was sent to embedder: " << message;
     return;
   }
 
   int id = 0;
   dict->GetInteger(kFrontendHostId, &id);
 
   std::string error;
   embedder_message_dispatcher_->Dispatch(method, params, &error);
   if (id) {
     base::FundamentalValue id_value(id);
     base::StringValue error_value(error);
     CallClientFunction("InspectorFrontendAPI.embedderMessageAck",
                        &id_value, &error_value, NULL);
   }
 }
 
+void DevToolsUIBindings::HandleMessageFromDevToolsFrontendToBackend(
+    const std::string& message) {
+  content::DevToolsManager::GetInstance()->DispatchOnInspectorBackend(
+      this, message);
+}
+
+// content::DevToolsClientHost implementation ---------------------------------
+void DevToolsUIBindings::DispatchOnInspectorFrontend(
+    const std::string& message) {
+  frontend_host_->DispatchOnDevToolsFrontend(message);

[pfeldman, 2014/07/31 11:47:25]

Can we use a CallClientFunction here?

[dgozman, 2014/07/31 13:05:31]

There is a TODO for that. It requires some blink-side changes.

+}
+
+void DevToolsUIBindings::InspectedContentsClosing() {
+  delegate_->InspectedContentsClosing();
+}
+
+void DevToolsUIBindings::ReplacedWithAnotherClient() {
+}
+
+// DevToolsEmbedderMessageDispatcher::Delegate implementation -----------------
 void DevToolsUIBindings::ActivateWindow() {
   delegate_->ActivateWindow();
 }
 
 void DevToolsUIBindings::CloseWindow() {
   delegate_->CloseWindow();
 }
 
 void DevToolsUIBindings::SetInspectedPageBounds(const gfx::Rect& rect) {
   delegate_->SetInspectedPageBounds(rect);
@@ skipping 367 matching lines @@
   web_contents_->GetMainFrame()->ExecuteJavaScript(javascript);
 }
 
 void DevToolsUIBindings::DocumentOnLoadCompletedInMainFrame() {
   // Call delegate first - it seeds importants bit of information.
   delegate_->OnLoadCompleted();
 
   UpdateTheme();
   AddDevToolsExtensionsToClient();
 }