[DevTools] Unify workers and web contents handling in inspect_ui.

chrome/browser/devtools/devtools_targets_ui.cc

 // Copyright 2013 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_targets_ui.h"
 
 #include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
@@ skipping 12 matching lines @@
 #include "content/public/browser/worker_service.h"
 #include "content/public/browser/worker_service_observer.h"
 #include "content/public/common/process_type.h"
 #include "net/base/escape.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const char kTargetSourceField[]  = "source";
-const char kTargetSourceRenderer[]  = "renderers";
-const char kTargetSourceWorker[]  = "workers";
-const char kTargetSourceAdb[]  = "adb";
+const char kTargetSourceLocal[]  = "local";
+const char kTargetSourceRemote[]  = "remote";
 
 const char kTargetIdField[]  = "id";
 const char kTargetTypeField[]  = "type";
 const char kAttachedField[]  = "attached";
 const char kUrlField[]  = "url";
 const char kNameField[]  = "name";
 const char kFaviconUrlField[] = "faviconUrl";
 const char kDescriptionField[] = "description";
 
 const char kGuestList[] = "guests";
@@ skipping 27 matching lines @@
         delay);
   }
 
  private:
   void Fire() { callback_.Run(); }
 
   base::Closure callback_;
   base::WeakPtrFactory<CancelableTimer> weak_factory_;
 };
 
-// RenderViewHostTargetsUIHandler ---------------------------------------------
-
-class RenderViewHostTargetsUIHandler
-    : public DevToolsTargetsUIHandler,
-      public content::NotificationObserver {
- public:
-  explicit RenderViewHostTargetsUIHandler(const Callback& callback);
-  virtual ~RenderViewHostTargetsUIHandler();
-
- private:
-  // content::NotificationObserver overrides.
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
-
-  void UpdateTargets();
-
-  content::NotificationRegistrar notification_registrar_;
-  scoped_ptr<CancelableTimer> timer_;
-};
-
-RenderViewHostTargetsUIHandler::RenderViewHostTargetsUIHandler(
-    const Callback& callback)
-    : DevToolsTargetsUIHandler(kTargetSourceRenderer, callback) {
-  notification_registrar_.Add(this,
-                              content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
-                              content::NotificationService::AllSources());
-  notification_registrar_.Add(this,
-                              content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
-                              content::NotificationService::AllSources());
-  notification_registrar_.Add(this,
-                              content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                              content::NotificationService::AllSources());
-  UpdateTargets();
-}
-
-RenderViewHostTargetsUIHandler::~RenderViewHostTargetsUIHandler() {
-  notification_registrar_.RemoveAll();
-}
-
-void RenderViewHostTargetsUIHandler::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  const int kUpdateDelay = 100;
-  timer_.reset(
-      new CancelableTimer(
-          base::Bind(&RenderViewHostTargetsUIHandler::UpdateTargets,
-                     base::Unretained(this)),
-          base::TimeDelta::FromMilliseconds(kUpdateDelay)));
-}
-
-void RenderViewHostTargetsUIHandler::UpdateTargets() {
-  base::ListValue list_value;
-
-  std::map<std::string, base::DictionaryValue*> id_to_descriptor;
-
-  DevToolsTargetImpl::List targets =
-      DevToolsTargetImpl::EnumerateWebContentsTargets();
-
-  STLDeleteValues(&targets_);
-  for (DevToolsTargetImpl::List::iterator it = targets.begin();
-      it != targets.end(); ++it) {
-    DevToolsTargetImpl* target = *it;
-    targets_[target->GetId()] = target;
-    id_to_descriptor[target->GetId()] = Serialize(*target);
-  }
-
-  for (TargetMap::iterator it(targets_.begin()); it != targets_.end(); ++it) {
-    DevToolsTargetImpl* target = it->second;
-    base::DictionaryValue* descriptor = id_to_descriptor[target->GetId()];
-
-    std::string parent_id = target->GetParentId();
-    if (parent_id.empty() || id_to_descriptor.count(parent_id) == 0) {
-      list_value.Append(descriptor);
-    } else {
-      base::DictionaryValue* parent = id_to_descriptor[parent_id];
-      base::ListValue* guests = NULL;
-      if (!parent->GetList(kGuestList, &guests)) {
-        guests = new base::ListValue();
-        parent->Set(kGuestList, guests);
-      }
-      guests->Append(descriptor);
-    }
-  }
-
-  SendSerializedTargets(list_value);
-}
-
 // WorkerObserver -------------------------------------------------------------
 
 class WorkerObserver
     : public content::WorkerServiceObserver,
       public base::RefCountedThreadSafe<WorkerObserver> {
  public:
   WorkerObserver() {}
 
-  void Start(DevToolsTargetImpl::Callback callback) {
+  void Start(base::Closure callback) {
     DCHECK(callback_.is_null());
     DCHECK(!callback.is_null());
     callback_ = callback;
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&WorkerObserver::StartOnIOThread, this));
   }
 
   void Stop() {
     DCHECK(!callback_.is_null());
-    callback_ = DevToolsTargetImpl::Callback();
+    callback_ = base::Closure();
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&WorkerObserver::StopOnIOThread, this));
   }
 
-  void Enumerate() {
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&WorkerObserver::EnumerateOnIOThread,
-                   this));
-  }
-
  private:
   friend class base::RefCountedThreadSafe<WorkerObserver>;
   virtual ~WorkerObserver() {}
 
   // content::WorkerServiceObserver overrides:
   virtual void WorkerCreated(
       const GURL& url,
       const base::string16& name,
       int process_id,
       int route_id) OVERRIDE {
-    EnumerateOnIOThread();
+    NotifyOnIOThread();
   }
 
   virtual void WorkerDestroyed(int process_id, int route_id) OVERRIDE {
-    EnumerateOnIOThread();
+    NotifyOnIOThread();
   }
 
   void StartOnIOThread() {
     content::WorkerService::GetInstance()->AddObserver(this);
-    EnumerateOnIOThread();
   }
 
   void StopOnIOThread() {
     content::WorkerService::GetInstance()->RemoveObserver(this);
   }
 
-  void EnumerateOnIOThread() {
+  void NotifyOnIOThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    DevToolsTargetImpl::EnumerateWorkerTargets(
-        base::Bind(&WorkerObserver::RespondOnUIThread, this));
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&WorkerObserver::NotifyOnUIThread, this));
   }
 
-  void RespondOnUIThread(const DevToolsTargetImpl::List& targets) {
+  void NotifyOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (callback_.is_null())
       return;
-    callback_.Run(targets);
+    callback_.Run();
   }
 
-  DevToolsTargetImpl::Callback callback_;
+  // Accessed on UI thread.
+  base::Closure callback_;
 };
 
-// WorkerTargetsUIHandler -----------------------------------------------------
+// LocalTargetsUIHandler ---------------------------------------------
 
-class WorkerTargetsUIHandler
-    : public DevToolsTargetsUIHandler {
+class LocalTargetsUIHandler
+    : public DevToolsTargetsUIHandler,
+      public content::NotificationObserver {
  public:
-  explicit WorkerTargetsUIHandler(const Callback& callback);
-  virtual ~WorkerTargetsUIHandler();
+  explicit LocalTargetsUIHandler(const Callback& callback);
+  virtual ~LocalTargetsUIHandler();
 
- private:
-  void UpdateTargets(const DevToolsTargetImpl::List& targets);
+private:
+  // content::NotificationObserver overrides.
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
 
+  void ScheduleUpdate();
+  void UpdateTargets();
+  void SendTargets(const DevToolsTargetImpl::List& targets);
+
+  content::NotificationRegistrar notification_registrar_;
+  scoped_ptr<CancelableTimer> timer_;
   scoped_refptr<WorkerObserver> observer_;
+  base::WeakPtrFactory<LocalTargetsUIHandler> weak_factory_;
 };
 
-WorkerTargetsUIHandler::WorkerTargetsUIHandler(const Callback& callback)
-    : DevToolsTargetsUIHandler(kTargetSourceWorker, callback),
-      observer_(new WorkerObserver()) {
-  observer_->Start(base::Bind(&WorkerTargetsUIHandler::UpdateTargets,
+LocalTargetsUIHandler::LocalTargetsUIHandler(
+    const Callback& callback)
+    : DevToolsTargetsUIHandler(kTargetSourceLocal, callback),
+      observer_(new WorkerObserver()),
+      weak_factory_(this) {
+  notification_registrar_.Add(this,
+                              content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
+                              content::NotificationService::AllSources());
+  notification_registrar_.Add(this,
+                              content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
+                              content::NotificationService::AllSources());
+  notification_registrar_.Add(this,
+                              content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
+                              content::NotificationService::AllSources());
+  observer_->Start(base::Bind(&LocalTargetsUIHandler::ScheduleUpdate,
                               base::Unretained(this)));
+  UpdateTargets();
 }
 
-WorkerTargetsUIHandler::~WorkerTargetsUIHandler() {
+LocalTargetsUIHandler::~LocalTargetsUIHandler() {
+  notification_registrar_.RemoveAll();
   observer_->Stop();
 }
 
-void WorkerTargetsUIHandler::UpdateTargets(
+void LocalTargetsUIHandler::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  ScheduleUpdate();
+}
+
+void LocalTargetsUIHandler::ScheduleUpdate() {
+  const int kUpdateDelay = 100;
+  timer_.reset(
+      new CancelableTimer(
+          base::Bind(&LocalTargetsUIHandler::UpdateTargets,
+                     base::Unretained(this)),
+          base::TimeDelta::FromMilliseconds(kUpdateDelay)));
+}
+
+void LocalTargetsUIHandler::UpdateTargets() {
+  DevToolsTargetImpl::EnumerateAllTargets(base::Bind(
+      &LocalTargetsUIHandler::SendTargets,
+      weak_factory_.GetWeakPtr()));
+}
+
+void LocalTargetsUIHandler::SendTargets(
     const DevToolsTargetImpl::List& targets) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::ListValue list_value;
+  std::map<std::string, base::DictionaryValue*> id_to_descriptor;
+
   STLDeleteValues(&targets_);
   for (DevToolsTargetImpl::List::const_iterator it = targets.begin();
       it != targets.end(); ++it) {
     DevToolsTargetImpl* target = *it;
-    list_value.Append(Serialize(*target));
+    if (target->GetType() == DevToolsTargetImpl::kTargetTypeServiceWorker)
+      continue;
     targets_[target->GetId()] = target;
+    id_to_descriptor[target->GetId()] = Serialize(*target);
   }
+
+  for (TargetMap::iterator it(targets_.begin()); it != targets_.end(); ++it) {
+    DevToolsTargetImpl* target = it->second;
+    if (target->GetType() == DevToolsTargetImpl::kTargetTypeServiceWorker)
+      continue;
+    base::DictionaryValue* descriptor = id_to_descriptor[target->GetId()];
+
+    std::string parent_id = target->GetParentId();
+    if (parent_id.empty() || id_to_descriptor.count(parent_id) == 0) {
+      list_value.Append(descriptor);
+    } else {
+      base::DictionaryValue* parent = id_to_descriptor[parent_id];
+      base::ListValue* guests = NULL;
+      if (!parent->GetList(kGuestList, &guests)) {
+        guests = new base::ListValue();
+        parent->Set(kGuestList, guests);
+      }
+      guests->Append(descriptor);
+    }
+  }
+
   SendSerializedTargets(list_value);
 }
 
 // AdbTargetsUIHandler --------------------------------------------------------
 
 class AdbTargetsUIHandler
     : public DevToolsTargetsUIHandler,
       public DevToolsAndroidBridge::DeviceListListener {
  public:
   AdbTargetsUIHandler(const Callback& callback, Profile* profile);
@@ skipping 13 matching lines @@
 
   Profile* profile_;
 
   typedef std::map<std::string,
       scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> > RemoteBrowsers;
   RemoteBrowsers remote_browsers_;
 };
 
 AdbTargetsUIHandler::AdbTargetsUIHandler(const Callback& callback,
                                          Profile* profile)
-    : DevToolsTargetsUIHandler(kTargetSourceAdb, callback),
+    : DevToolsTargetsUIHandler(kTargetSourceRemote, callback),
       profile_(profile) {
   DevToolsAndroidBridge* android_bridge =
       DevToolsAndroidBridge::Factory::GetForProfile(profile_);
   if (android_bridge)
     android_bridge->AddDeviceListListener(this);
 }
 
 AdbTargetsUIHandler::~AdbTargetsUIHandler() {
   DevToolsAndroidBridge* android_bridge =
       DevToolsAndroidBridge::Factory::GetForProfile(profile_);
@@ skipping 116 matching lines @@
     : source_id_(source_id),
       callback_(callback) {
 }
 
 DevToolsTargetsUIHandler::~DevToolsTargetsUIHandler() {
   STLDeleteValues(&targets_);
 }
 
 // static
 scoped_ptr<DevToolsTargetsUIHandler>
-DevToolsTargetsUIHandler::CreateForRenderers(
+DevToolsTargetsUIHandler::CreateForLocal(
     const DevToolsTargetsUIHandler::Callback& callback) {
   return scoped_ptr<DevToolsTargetsUIHandler>(
-      new RenderViewHostTargetsUIHandler(callback));
+      new LocalTargetsUIHandler(callback));
 }
 
 // static
-scoped_ptr<DevToolsTargetsUIHandler>
-DevToolsTargetsUIHandler::CreateForWorkers(
-    const DevToolsTargetsUIHandler::Callback& callback) {
-  return scoped_ptr<DevToolsTargetsUIHandler>(
-      new WorkerTargetsUIHandler(callback));
-}
-
-// static
 scoped_ptr<DevToolsTargetsUIHandler>
 DevToolsTargetsUIHandler::CreateForAdb(
     const DevToolsTargetsUIHandler::Callback& callback, Profile* profile) {
   return scoped_ptr<DevToolsTargetsUIHandler>(
       new AdbTargetsUIHandler(callback, profile));
 }
 
 DevToolsTargetImpl* DevToolsTargetsUIHandler::GetTarget(
     const std::string& target_id) {
   TargetMap::iterator it = targets_.find(target_id);
@@ skipping 64 matching lines @@
           base::StringPrintf("%d", it->first), it->second);
     }
 
     std::string device_id = base::StringPrintf(
         kAdbDeviceIdFormat,
         sit->first.c_str());
     result.Set(device_id, device_status_dict);
   }
   callback_.Run(result);
 }