DevTools: factor out InspectorFrontendHost/API as a separate entity (chrome)

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 45 matching lines @@
 using base::DictionaryValue;
 using content::BrowserThread;
 
 namespace {
 
 static const char kFrontendHostId[] = "id";
 static const char kFrontendHostMethod[] = "method";
 static const char kFrontendHostParams[] = "params";
 static const char kTitleFormat[] = "Developer Tools - %s";
 
-static const char kDevicesChanged[] = "DevicesChanged";
-static const char kDeviceCountChanged[] = "DeviceCountChanged";
-
 std::string SkColorToRGBAString(SkColor color) {
   // We avoid StringPrintf because it will use locale specific formatters for
   // the double (e.g. ',' instead of '.' in German).
   return "rgba(" + base::IntToString(SkColorGetR(color)) + "," +
       base::IntToString(SkColorGetG(color)) + "," +
       base::IntToString(SkColorGetB(color)) + "," +
       base::DoubleToString(SkColorGetA(color) / 255.0) + ")";
 }
 
 base::DictionaryValue* CreateFileSystemValue(
@@ skipping 221 matching lines @@
       switches::kEnableDevToolsExperiments))
     url_string += "&experiments=true";
   return GURL(url_string);
 }
 
 DevToolsUIBindings::DevToolsUIBindings(content::WebContents* web_contents,
                                        const GURL& url)
     : profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())),
       web_contents_(web_contents),
       delegate_(new DefaultBindingsDelegate(web_contents_)),
-      device_listener_enabled_(false),
+      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(
       web_contents_, this));
   file_helper_.reset(new DevToolsFileHelper(web_contents_, profile_));
   file_system_indexer_ = new DevToolsFileSystemIndexer();
   extensions::ChromeExtensionWebContentsObserver::CreateForWebContents(
@@ skipping 21 matching lines @@
 
 DevToolsUIBindings::~DevToolsUIBindings() {
   content::DevToolsManager::GetInstance()->ClientHostClosing(
       frontend_host_.get());
 
   for (IndexingJobsMap::const_iterator jobs_it(indexing_jobs_.begin());
        jobs_it != indexing_jobs_.end(); ++jobs_it) {
     jobs_it->second->Stop();
   }
   indexing_jobs_.clear();
-
-  while (!subscribers_.empty())
-    Unsubscribe(*subscribers_.begin());
+  SetDeviceCountUpdatesEnabled(false);
+  SetDevicesUpdatesEnabled(false);
 }
 
 void DevToolsUIBindings::InspectedContentsClosing() {
   delegate_->InspectedContentsClosing();
 }
 
 void DevToolsUIBindings::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_BROWSER_THEME_CHANGED, type);
@@ skipping 199 matching lines @@
 
 void DevToolsUIBindings::OpenUrlOnRemoteDeviceAndInspect(
     const std::string& browser_id,
     const std::string& url) {
   if (remote_targets_handler_) {
     remote_targets_handler_->Open(browser_id, url,
         base::Bind(&InspectTarget, profile_));
   }
 }
 
-void DevToolsUIBindings::Subscribe(const std::string& event_type) {
-  if (subscribers_.find(event_type) != subscribers_.end()) {
-    LOG(ERROR) << "Already subscribed for [" << event_type << "].";
+void DevToolsUIBindings::SetDeviceCountUpdatesEnabled(bool enabled) {
+  if (device_count_updates_enabled_ == enabled)
     return;
-  }
-
-  subscribers_.insert(event_type);
-
-  if (event_type == kDevicesChanged) {
-    remote_targets_handler_ = DevToolsTargetsUIHandler::CreateForAdb(
-        base::Bind(&DevToolsUIBindings::PopulateRemoteDevices,
-                   base::Unretained(this)),
-        profile_);
-  } else if (event_type == kDeviceCountChanged) {
-    EnableRemoteDeviceCounter(true);
-  } else {
-    LOG(ERROR) << "Attempt to start unknown event listener " << event_type;
-  }
-}
-
-void DevToolsUIBindings::Unsubscribe(const std::string& event_type) {
-  if (subscribers_.find(event_type) == subscribers_.end()) {
-    LOG(ERROR) << "Not yet subscribed for [" << event_type << "]";
-    return;
-  }
-
-  if (event_type == kDevicesChanged) {
-    remote_targets_handler_.reset();
-  } else if (event_type == kDeviceCountChanged) {
-    EnableRemoteDeviceCounter(false);
-  } else {
-    LOG(ERROR) << "Attempt to stop unknown event listener " << event_type;
-  }
-
-  subscribers_.erase(event_type);
-}
-
-void DevToolsUIBindings::EnableRemoteDeviceCounter(bool enable) {
   DevToolsAndroidBridge* adb_bridge =
       DevToolsAndroidBridge::Factory::GetForProfile(profile_);
   if (!adb_bridge)
     return;
 
-  DCHECK(device_listener_enabled_ != enable);
-  device_listener_enabled_ = enable;
-  if (enable)
+  device_count_updates_enabled_ = enabled;
+  if (enabled)
     adb_bridge->AddDeviceCountListener(this);
   else
     adb_bridge->RemoveDeviceCountListener(this);
 }
 
-void DevToolsUIBindings::DeviceCountChanged(int count) {
-  DispatchEventOnFrontend(kDeviceCountChanged, base::FundamentalValue(count));
+void DevToolsUIBindings::SetDevicesUpdatesEnabled(bool enabled) {
+  if (devices_updates_enabled_ == enabled)
+    return;
+  devices_updates_enabled_ = enabled;
+  if (enabled) {
+    remote_targets_handler_ = DevToolsTargetsUIHandler::CreateForAdb(
+        base::Bind(&DevToolsUIBindings::DevicesUpdated,
+                   base::Unretained(this)),
+        profile_);
+  } else {
+    remote_targets_handler_.reset();
+  }
 }
 
-void DevToolsUIBindings::PopulateRemoteDevices(
+void DevToolsUIBindings::DeviceCountChanged(int count) {
+  base::FundamentalValue value(count);
+  CallClientFunction("InspectorFrontendAPI.deviceCountUpdated", &value, NULL,
+                     NULL);
+}
+
+void DevToolsUIBindings::DevicesUpdated(
     const std::string& source,
     const base::ListValue& targets) {
-  DispatchEventOnFrontend(kDevicesChanged, targets);
+  CallClientFunction("InspectorFrontendAPI.devicesUpdated", &targets, NULL,
+                     NULL);
 }
 
 void DevToolsUIBindings::FileSavedAs(const std::string& url) {
   base::StringValue url_value(url);
   CallClientFunction("InspectorFrontendAPI.savedURL", &url_value, NULL, NULL);
 }
 
 void DevToolsUIBindings::CanceledFileSaveAs(const std::string& url) {
   base::StringValue url_value(url);
   CallClientFunction("InspectorFrontendAPI.canceledSaveURL",
@@ skipping 143 matching lines @@
         base::JSONWriter::Write(arg3, &json);
         params.append(", " + json);
       }
     }
   }
   base::string16 javascript =
       base::UTF8ToUTF16(function_name + "(" + params + ");");
   web_contents_->GetMainFrame()->ExecuteJavaScript(javascript);
 }
 
-void DevToolsUIBindings::DispatchEventOnFrontend(
-    const std::string& event_type,
-    const base::Value& event_data) {
-  if (subscribers_.find(event_type) == subscribers_.end())
-    return;
-  base::StringValue event_type_value(event_type);
-  CallClientFunction("InspectorFrontendAPI.dispatchEventToListeners",
-                     &event_type_value,
-                     &event_data,
-                     NULL);
-}
-
 void DevToolsUIBindings::DocumentOnLoadCompletedInMainFrame() {
   // Call delegate first - it seeds importants bit of information.
   delegate_->OnLoadCompleted();
 
   UpdateTheme();
   AddDevToolsExtensionsToClient();
 }