#include "base/stl_util.h"
#include "base/strings/stringprintf.h"
#include "base/values.h"
-#include "chrome/browser/devtools/devtools_adb_bridge.h"
+#include "base/version.h"
+#include "chrome/browser/devtools/device/devtools_android_bridge.h"
#include "chrome/browser/devtools/devtools_target_impl.h"
-#include "chrome/browser/devtools/port_forwarding_controller.h"
+#include "chrome/common/chrome_version_info.h"
#include "content/public/browser/browser_child_process_observer.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/child_process_data.h"
#include "content/public/browser/notification_service.h"
#include "content/public/browser/notification_source.h"
#include "content/public/browser/notification_types.h"
-#include "content/public/browser/render_process_host.h"
-#include "content/public/browser/render_view_host.h"
-#include "content/public/browser/web_contents.h"
#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;
-using content::WebContents;
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 kAdbModelField[] = "adbModel";
const char kAdbConnectedField[] = "adbConnected";
const char kAdbSerialField[] = "adbSerial";
-const char kAdbPortStatus[] = "adbPortStatus";
const char kAdbBrowsersList[] = "browsers";
+const char kAdbDeviceIdFormat[] = "device:%s";
const char kAdbBrowserNameField[] = "adbBrowserName";
const char kAdbBrowserVersionField[] = "adbBrowserVersion";
const char kAdbBrowserChromeVersionField[] = "adbBrowserChromeVersion";
+const char kCompatibleVersion[] = "compatibleVersion";
const char kAdbPagesList[] = "pages";
const char kAdbScreenWidthField[] = "adbScreenWidth";
FROM_HERE,
base::Bind(&CancelableTimer::Fire, weak_factory_.GetWeakPtr()),
delay);
- };
+ }
private:
void Fire() { callback_.Run(); }
base::WeakPtrFactory<CancelableTimer> weak_factory_;
};
-// RenderViewHostTargetsUIHandler ---------------------------------------------
-
-class RenderViewHostTargetsUIHandler
- : public DevToolsTargetsUIHandler,
- public content::NotificationObserver {
- public:
- explicit RenderViewHostTargetsUIHandler(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(
- 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() {
- scoped_ptr<base::ListValue> list_value(new base::ListValue());
-
- std::map<WebContents*, base::DictionaryValue*> web_contents_to_descriptor_;
- std::vector<DevToolsTargetImpl*> guest_targets;
-
- DevToolsTargetImpl::List targets =
- DevToolsTargetImpl::EnumerateRenderViewHostTargets();
-
- STLDeleteValues(&targets_);
- for (DevToolsTargetImpl::List::iterator it = targets.begin();
- it != targets.end(); ++it) {
- scoped_ptr<DevToolsTargetImpl> target(*it);
- content::RenderViewHost* rvh = target->GetRenderViewHost();
- if (!rvh)
- continue;
- WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
- if (!web_contents)
- continue;
-
- DevToolsTargetImpl* target_ptr = target.get();
- targets_[target_ptr->GetId()] = target.release();
- if (rvh->GetProcess()->IsGuest()) {
- guest_targets.push_back(target_ptr);
- } else {
- base::DictionaryValue* descriptor = Serialize(*target_ptr);
- list_value->Append(descriptor);
- web_contents_to_descriptor_[web_contents] = descriptor;
- }
- }
-
- // Add the list of guest-views to each of its embedders.
- for (std::vector<DevToolsTargetImpl*>::iterator it(guest_targets.begin());
- it != guest_targets.end(); ++it) {
- DevToolsTargetImpl* guest = (*it);
- WebContents* guest_web_contents =
- WebContents::FromRenderViewHost(guest->GetRenderViewHost());
- WebContents* embedder = guest_web_contents->GetEmbedderWebContents();
- if (embedder && web_contents_to_descriptor_.count(embedder) > 0) {
- base::DictionaryValue* parent = web_contents_to_descriptor_[embedder];
- base::ListValue* guests = NULL;
- if (!parent->GetList(kGuestList, &guests)) {
- guests = new base::ListValue();
- parent->Set(kGuestList, guests);
- }
- guests->Append(Serialize(*guest));
- }
- }
-
- SendSerializedTargets(list_value.Pass());
-}
-
// WorkerObserver -------------------------------------------------------------
class WorkerObserver
public:
WorkerObserver() {}
- void Start(DevToolsTargetImpl::Callback callback) {
+ void Start(base::Closure callback) {
DCHECK(callback_.is_null());
DCHECK(!callback.is_null());
callback_ = callback;
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() {}
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
+class LocalTargetsUIHandler
: public DevToolsTargetsUIHandler,
- public content::BrowserChildProcessObserver {
+ public content::NotificationObserver {
public:
- explicit WorkerTargetsUIHandler(Callback callback);
- virtual ~WorkerTargetsUIHandler();
+ explicit LocalTargetsUIHandler(const Callback& callback);
+ virtual ~LocalTargetsUIHandler();
- private:
- // content::BrowserChildProcessObserver overrides.
- virtual void BrowserChildProcessHostConnected(
- const content::ChildProcessData& data) OVERRIDE;
- virtual void BrowserChildProcessHostDisconnected(
- const content::ChildProcessData& data) OVERRIDE;
+ // DevToolsTargetsUIHandler overrides.
+ virtual void ForceUpdate() OVERRIDE;
+
+private:
+ // content::NotificationObserver overrides.
+ virtual void Observe(int type,
+ const content::NotificationSource& source,
+ const content::NotificationDetails& details) OVERRIDE;
- void UpdateTargets(const DevToolsTargetImpl::List& targets);
+ 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(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)));
- BrowserChildProcessObserver::Add(this);
+ UpdateTargets();
}
-WorkerTargetsUIHandler::~WorkerTargetsUIHandler() {
- BrowserChildProcessObserver::Remove(this);
+LocalTargetsUIHandler::~LocalTargetsUIHandler() {
+ notification_registrar_.RemoveAll();
observer_->Stop();
}
-void WorkerTargetsUIHandler::BrowserChildProcessHostConnected(
- const content::ChildProcessData& data) {
- if (data.process_type == content::PROCESS_TYPE_WORKER)
- observer_->Enumerate();
+void LocalTargetsUIHandler::Observe(
+ int type,
+ const content::NotificationSource& source,
+ const content::NotificationDetails& details) {
+ ScheduleUpdate();
}
-void WorkerTargetsUIHandler::BrowserChildProcessHostDisconnected(
- const content::ChildProcessData& data) {
- if (data.process_type == content::PROCESS_TYPE_WORKER)
- observer_->Enumerate();
+void LocalTargetsUIHandler::ForceUpdate() {
+ ScheduleUpdate();
}
-void WorkerTargetsUIHandler::UpdateTargets(
+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));
- scoped_ptr<base::ListValue> list_value(new base::ListValue());
+ 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));
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.Pass());
+
+ SendSerializedTargets(list_value);
}
// AdbTargetsUIHandler --------------------------------------------------------
class AdbTargetsUIHandler
- : public DevToolsRemoteTargetsUIHandler,
- public DevToolsAdbBridge::Listener {
+ : public DevToolsTargetsUIHandler,
+ public DevToolsAndroidBridge::DeviceListListener {
public:
- AdbTargetsUIHandler(Callback callback, Profile* profile);
+ AdbTargetsUIHandler(const Callback& callback, Profile* profile);
virtual ~AdbTargetsUIHandler();
virtual void Open(const std::string& browser_id,
- const std::string& url) OVERRIDE;
+ const std::string& url,
+ const DevToolsTargetsUIHandler::TargetCallback&) OVERRIDE;
+
+ virtual scoped_refptr<content::DevToolsAgentHost> GetBrowserAgentHost(
+ const std::string& browser_id) OVERRIDE;
private:
- // DevToolsAdbBridge::Listener overrides.
- virtual void RemoteDevicesChanged(
- DevToolsAdbBridge::RemoteDevices* devices) OVERRIDE;
+ // DevToolsAndroidBridge::Listener overrides.
+ virtual void DeviceListChanged(
+ const DevToolsAndroidBridge::RemoteDevices& devices) OVERRIDE;
Profile* profile_;
typedef std::map<std::string,
- scoped_refptr<DevToolsAdbBridge::RemoteBrowser> > RemoteBrowsers;
+ scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> > RemoteBrowsers;
RemoteBrowsers remote_browsers_;
};
-AdbTargetsUIHandler::AdbTargetsUIHandler(Callback callback, Profile* profile)
- : DevToolsRemoteTargetsUIHandler(kTargetSourceAdb, callback),
+AdbTargetsUIHandler::AdbTargetsUIHandler(const Callback& callback,
+ Profile* profile)
+ : DevToolsTargetsUIHandler(kTargetSourceRemote, callback),
profile_(profile) {
- DevToolsAdbBridge* adb_bridge =
- DevToolsAdbBridge::Factory::GetForProfile(profile_);
- if (adb_bridge)
- adb_bridge->AddListener(this);
+ DevToolsAndroidBridge* android_bridge =
+ DevToolsAndroidBridge::Factory::GetForProfile(profile_);
+ if (android_bridge)
+ android_bridge->AddDeviceListListener(this);
}
AdbTargetsUIHandler::~AdbTargetsUIHandler() {
- DevToolsAdbBridge* adb_bridge =
- DevToolsAdbBridge::Factory::GetForProfile(profile_);
- if (adb_bridge)
- adb_bridge->RemoveListener(this);
+ DevToolsAndroidBridge* android_bridge =
+ DevToolsAndroidBridge::Factory::GetForProfile(profile_);
+ if (android_bridge)
+ android_bridge->RemoveDeviceListListener(this);
}
-void AdbTargetsUIHandler::Open(const std::string& browser_id,
- const std::string& url) {
+static void CallOnTarget(
+ const DevToolsTargetsUIHandler::TargetCallback& callback,
+ DevToolsAndroidBridge::RemotePage* page) {
+ scoped_ptr<DevToolsAndroidBridge::RemotePage> my_page(page);
+ callback.Run(my_page ? my_page->GetTarget() : NULL);
+}
+
+void AdbTargetsUIHandler::Open(
+ const std::string& browser_id,
+ const std::string& url,
+ const DevToolsTargetsUIHandler::TargetCallback& callback) {
RemoteBrowsers::iterator it = remote_browsers_.find(browser_id);
if (it != remote_browsers_.end())
- it->second->Open(url);
+ it->second->Open(url, base::Bind(&CallOnTarget, callback));
}
-void AdbTargetsUIHandler::RemoteDevicesChanged(
- DevToolsAdbBridge::RemoteDevices* devices) {
- PortForwardingController* port_forwarding_controller =
- PortForwardingController::Factory::GetForProfile(profile_);
- PortForwardingController::DevicesStatus port_forwarding_status;
- if (port_forwarding_controller)
- port_forwarding_status =
- port_forwarding_controller->UpdateDeviceList(*devices);
+scoped_refptr<content::DevToolsAgentHost>
+AdbTargetsUIHandler::GetBrowserAgentHost(
+ const std::string& browser_id) {
+ RemoteBrowsers::iterator it = remote_browsers_.find(browser_id);
+ return it != remote_browsers_.end() ? it->second->GetAgentHost() : NULL;
+}
+void AdbTargetsUIHandler::DeviceListChanged(
+ const DevToolsAndroidBridge::RemoteDevices& devices) {
remote_browsers_.clear();
STLDeleteValues(&targets_);
- scoped_ptr<base::ListValue> device_list(new base::ListValue());
- for (DevToolsAdbBridge::RemoteDevices::iterator dit = devices->begin();
- dit != devices->end(); ++dit) {
- DevToolsAdbBridge::RemoteDevice* device = dit->get();
+ base::ListValue device_list;
+ for (DevToolsAndroidBridge::RemoteDevices::const_iterator dit =
+ devices.begin(); dit != devices.end(); ++dit) {
+ DevToolsAndroidBridge::RemoteDevice* device = dit->get();
base::DictionaryValue* device_data = new base::DictionaryValue();
- device_data->SetString(kAdbModelField, device->GetModel());
- device_data->SetString(kAdbSerialField, device->GetSerial());
- device_data->SetBoolean(kAdbConnectedField, device->IsConnected());
+ device_data->SetString(kAdbModelField, device->model());
+ device_data->SetString(kAdbSerialField, device->serial());
+ device_data->SetBoolean(kAdbConnectedField, device->is_connected());
std::string device_id = base::StringPrintf(
- "device:%s",
- device->GetSerial().c_str());
+ kAdbDeviceIdFormat,
+ device->serial().c_str());
device_data->SetString(kTargetIdField, device_id);
base::ListValue* browser_list = new base::ListValue();
device_data->Set(kAdbBrowsersList, browser_list);
- DevToolsAdbBridge::RemoteBrowsers& browsers = device->browsers();
- for (DevToolsAdbBridge::RemoteBrowsers::iterator bit =
+ DevToolsAndroidBridge::RemoteBrowsers& browsers = device->browsers();
+ for (DevToolsAndroidBridge::RemoteBrowsers::iterator bit =
browsers.begin(); bit != browsers.end(); ++bit) {
- DevToolsAdbBridge::RemoteBrowser* browser = bit->get();
+ DevToolsAndroidBridge::RemoteBrowser* browser = bit->get();
base::DictionaryValue* browser_data = new base::DictionaryValue();
browser_data->SetString(kAdbBrowserNameField, browser->display_name());
browser_data->SetString(kAdbBrowserVersionField, browser->version());
- DevToolsAdbBridge::RemoteBrowser::ParsedVersion parsed =
+ DevToolsAndroidBridge::RemoteBrowser::ParsedVersion parsed =
browser->GetParsedVersion();
browser_data->SetInteger(
kAdbBrowserChromeVersionField,
browser->IsChrome() && !parsed.empty() ? parsed[0] : 0);
std::string browser_id = base::StringPrintf(
"browser:%s:%s:%s:%s",
- device->GetSerial().c_str(), // Ensure uniqueness across devices.
+ device->serial().c_str(), // Ensure uniqueness across devices.
browser->display_name().c_str(), // Sort by display name.
browser->version().c_str(), // Then by version.
browser->socket().c_str()); // Ensure uniqueness on the device.
browser_data->SetString(kTargetIdField, browser_id);
browser_data->SetString(kTargetSourceField, source_id());
- remote_browsers_[browser_id] = browser;
- base::ListValue* page_list = new base::ListValue();
- browser_data->Set(kAdbPagesList, page_list);
- DevToolsTargetImpl::List pages = browser->CreatePageTargets();
- for (DevToolsTargetImpl::List::iterator it =
+ base::Version remote_version;
+ remote_version = base::Version(browser->version());
+
+ chrome::VersionInfo version_info;
+ base::Version local_version(version_info.Version());
+
+ browser_data->SetBoolean(kCompatibleVersion,
+ (!remote_version.IsValid()) || (!local_version.IsValid()) ||
+ remote_version.components()[0] <= local_version.components()[0]);
+
+ base::ListValue* page_list = new base::ListValue();
+ remote_browsers_[browser_id] = browser;
+ browser_data->Set(kAdbPagesList, page_list);
+ std::vector<DevToolsAndroidBridge::RemotePage*> pages =
+ browser->CreatePages();
+ for (std::vector<DevToolsAndroidBridge::RemotePage*>::iterator it =
pages.begin(); it != pages.end(); ++it) {
- DevToolsTargetImpl* target = *it;
+ DevToolsAndroidBridge::RemotePage* page = *it;
+ DevToolsTargetImpl* target = page->GetTarget();
base::DictionaryValue* target_data = Serialize(*target);
target_data->SetBoolean(
kAdbAttachedForeignField,
target->IsAttached() &&
- !DevToolsAdbBridge::HasDevToolsWindow(target->GetId()));
+ !DevToolsAndroidBridge::HasDevToolsWindow(target->GetId()));
// Pass the screen size in the target object to make sure that
// the caching logic does not prevent the target item from updating
// when the screen size changes.
browser_list->Append(browser_data);
}
- if (port_forwarding_controller) {
- PortForwardingController::DevicesStatus::iterator sit =
- port_forwarding_status.find(device->GetSerial());
- if (sit != port_forwarding_status.end()) {
- base::DictionaryValue* port_status_dict = new base::DictionaryValue();
- typedef PortForwardingController::PortStatusMap StatusMap;
- const StatusMap& port_status = sit->second;
- for (StatusMap::const_iterator it = port_status.begin();
- it != port_status.end(); ++it) {
- port_status_dict->SetInteger(
- base::StringPrintf("%d", it->first), it->second);
- }
- device_data->Set(kAdbPortStatus, port_status_dict);
- }
- }
-
- device_list->Append(device_data);
+ device_list.Append(device_data);
}
- SendSerializedTargets(device_list.Pass());
+ SendSerializedTargets(device_list);
}
} // namespace
DevToolsTargetsUIHandler::DevToolsTargetsUIHandler(
const std::string& source_id,
- Callback callback)
+ const Callback& callback)
: source_id_(source_id),
callback_(callback) {
}
// static
scoped_ptr<DevToolsTargetsUIHandler>
-DevToolsTargetsUIHandler::CreateForRenderers(
- DevToolsTargetsUIHandler::Callback callback) {
+DevToolsTargetsUIHandler::CreateForLocal(
+ const DevToolsTargetsUIHandler::Callback& callback) {
return scoped_ptr<DevToolsTargetsUIHandler>(
- new RenderViewHostTargetsUIHandler(callback));
+ new LocalTargetsUIHandler(callback));
}
// static
scoped_ptr<DevToolsTargetsUIHandler>
-DevToolsTargetsUIHandler::CreateForWorkers(
- DevToolsTargetsUIHandler::Callback callback) {
+DevToolsTargetsUIHandler::CreateForAdb(
+ const DevToolsTargetsUIHandler::Callback& callback, Profile* profile) {
return scoped_ptr<DevToolsTargetsUIHandler>(
- new WorkerTargetsUIHandler(callback));
-}
-
-void DevToolsTargetsUIHandler::Inspect(const std::string& target_id,
- Profile* profile) {
- TargetMap::iterator it = targets_.find(target_id);
- if (it != targets_.end())
- it->second->Inspect(profile);
+ new AdbTargetsUIHandler(callback, profile));
}
-void DevToolsTargetsUIHandler::Activate(const std::string& target_id) {
+DevToolsTargetImpl* DevToolsTargetsUIHandler::GetTarget(
+ const std::string& target_id) {
TargetMap::iterator it = targets_.find(target_id);
if (it != targets_.end())
- it->second->Activate();
+ return it->second;
+ return NULL;
}
-void DevToolsTargetsUIHandler::Close(const std::string& target_id) {
- TargetMap::iterator it = targets_.find(target_id);
- if (it != targets_.end())
- it->second->Close();
+void DevToolsTargetsUIHandler::Open(const std::string& browser_id,
+ const std::string& url,
+ const TargetCallback& callback) {
+ callback.Run(NULL);
}
-void DevToolsTargetsUIHandler::Reload(const std::string& target_id) {
- TargetMap::iterator it = targets_.find(target_id);
- if (it != targets_.end())
- it->second->Reload();
+scoped_refptr<content::DevToolsAgentHost>
+DevToolsTargetsUIHandler::GetBrowserAgentHost(const std::string& browser_id) {
+ return NULL;
}
-base::DictionaryValue*
-DevToolsTargetsUIHandler::Serialize(
+base::DictionaryValue* DevToolsTargetsUIHandler::Serialize(
const DevToolsTargetImpl& target) {
base::DictionaryValue* target_data = new base::DictionaryValue();
target_data->SetString(kTargetSourceField, source_id_);
target_data->SetString(kTargetIdField, target.GetId());
target_data->SetString(kTargetTypeField, target.GetType());
target_data->SetBoolean(kAttachedField, target.IsAttached());
- target_data->SetString(kUrlField, target.GetUrl().spec());
+ target_data->SetString(kUrlField, target.GetURL().spec());
target_data->SetString(kNameField, net::EscapeForHTML(target.GetTitle()));
- target_data->SetString(kFaviconUrlField, target.GetFaviconUrl().spec());
+ target_data->SetString(kFaviconUrlField, target.GetFaviconURL().spec());
target_data->SetString(kDescriptionField, target.GetDescription());
return target_data;
}
void DevToolsTargetsUIHandler::SendSerializedTargets(
- scoped_ptr<base::ListValue> list) {
- callback_.Run(source_id_, list.Pass());
+ const base::ListValue& list) {
+ callback_.Run(source_id_, list);
+}
+
+void DevToolsTargetsUIHandler::ForceUpdate() {
}
-// DevToolsRemoteTargetsUIHandler ---------------------------------------------
+// PortForwardingStatusSerializer ---------------------------------------------
-DevToolsRemoteTargetsUIHandler::DevToolsRemoteTargetsUIHandler(
- const std::string& source_id,
- Callback callback)
- : DevToolsTargetsUIHandler(source_id, callback) {
+PortForwardingStatusSerializer::PortForwardingStatusSerializer(
+ const Callback& callback, Profile* profile)
+ : callback_(callback),
+ profile_(profile) {
+ DevToolsAndroidBridge* android_bridge =
+ DevToolsAndroidBridge::Factory::GetForProfile(profile_);
+ if (android_bridge)
+ android_bridge->AddPortForwardingListener(this);
}
-// static
-scoped_ptr<DevToolsRemoteTargetsUIHandler>
-DevToolsRemoteTargetsUIHandler::CreateForAdb(
- DevToolsTargetsUIHandler::Callback callback, Profile* profile) {
- return scoped_ptr<DevToolsRemoteTargetsUIHandler>(
- new AdbTargetsUIHandler(callback, profile));
+PortForwardingStatusSerializer::~PortForwardingStatusSerializer() {
+ DevToolsAndroidBridge* android_bridge =
+ DevToolsAndroidBridge::Factory::GetForProfile(profile_);
+ if (android_bridge)
+ android_bridge->RemovePortForwardingListener(this);
+}
+
+void PortForwardingStatusSerializer::PortStatusChanged(
+ const DevicesStatus& status) {
+ base::DictionaryValue result;
+ for (DevicesStatus::const_iterator sit = status.begin();
+ sit != status.end(); ++sit) {
+ base::DictionaryValue* device_status_dict = new base::DictionaryValue();
+ const PortStatusMap& device_status_map = sit->second;
+ for (PortStatusMap::const_iterator it = device_status_map.begin();
+ it != device_status_map.end(); ++it) {
+ device_status_dict->SetInteger(
+ 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);
}
projects / platform / framework / web / crosswalk.git / blobdiff