Index: chrome/browser/devtools/device/devtools_android_bridge.cc |
diff --git a/chrome/browser/devtools/device/devtools_android_bridge.cc b/chrome/browser/devtools/device/devtools_android_bridge.cc |
index 1a674dfa394e2eec144154033d4979ab78c65acc..5bf7b550be6e656189d5432afd05be2b4f35ff16 100644 |
--- a/chrome/browser/devtools/device/devtools_android_bridge.cc |
+++ b/chrome/browser/devtools/device/devtools_android_bridge.cc |
@@ -41,8 +41,6 @@ using content::BrowserThread; |
namespace { |
-const char kModelOffline[] = "Offline"; |
- |
const char kPageListRequest[] = "/json"; |
const char kVersionRequest[] = "/json/version"; |
const char kClosePageRequest[] = "/json/close/%s"; |
@@ -65,14 +63,14 @@ class DiscoveryRequest : public base::RefCountedThreadSafe< |
DiscoveryRequest, |
BrowserThread::DeleteOnUIThread> { |
public: |
- typedef base::Callback<void(DevToolsAndroidBridge::RemoteDevices*)> Callback; |
+ typedef base::Callback<void(scoped_ptr<DevToolsAndroidBridge::RemoteDevices>)> |
+ DiscoveryCallback; |
+ typedef AndroidDeviceManager::Device Device; |
+ typedef AndroidDeviceManager::Devices Devices; |
DiscoveryRequest( |
- scoped_refptr<DevToolsAndroidBridge> android_bridge, |
AndroidDeviceManager* device_manager, |
- base::MessageLoop* device_message_loop, |
- const AndroidDeviceManager::DeviceProviders& device_providers, |
- const Callback& callback); |
+ const DiscoveryCallback& callback); |
private: |
friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>; |
@@ -80,14 +78,14 @@ class DiscoveryRequest : public base::RefCountedThreadSafe< |
virtual ~DiscoveryRequest(); |
- void ReceivedSerials(const std::vector<std::string>& serials); |
- void ProcessSerials(); |
+ void ReceivedDevices(const Devices& devices); |
+ void ProcessDevices(); |
void ReceivedDeviceInfo(const AndroidDeviceManager::DeviceInfo& device_info); |
void ProcessSockets(); |
void ReceivedVersion(int result, const std::string& response); |
void ReceivedPages(int result, const std::string& response); |
- std::string current_serial() const { return serials_.back(); } |
+ scoped_refptr<Device> current_device() { return devices_.back(); } |
scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> current_browser() const { |
return browsers_.back(); |
@@ -98,84 +96,59 @@ class DiscoveryRequest : public base::RefCountedThreadSafe< |
void Respond(); |
- scoped_refptr<DevToolsAndroidBridge> android_bridge_; |
- AndroidDeviceManager* device_manager_; |
- base::MessageLoop* device_message_loop_; |
- Callback callback_; |
- std::vector<std::string> serials_; |
+ DiscoveryCallback callback_; |
+ Devices devices_; |
DevToolsAndroidBridge::RemoteBrowsers browsers_; |
scoped_ptr<DevToolsAndroidBridge::RemoteDevices> remote_devices_; |
}; |
DiscoveryRequest::DiscoveryRequest( |
- scoped_refptr<DevToolsAndroidBridge> android_bridge, |
AndroidDeviceManager* device_manager, |
- base::MessageLoop* device_message_loop, |
- const AndroidDeviceManager::DeviceProviders& device_providers, |
- const Callback& callback) |
- : android_bridge_(android_bridge), |
- device_manager_(device_manager), |
- device_message_loop_(device_message_loop), |
- callback_(callback) { |
+ const DiscoveryCallback& callback) |
+ : callback_(callback) { |
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
remote_devices_.reset(new DevToolsAndroidBridge::RemoteDevices()); |
- device_message_loop_->PostTask( |
- FROM_HERE, base::Bind( |
- &AndroidDeviceManager::QueryDevices, |
- device_manager_, |
- device_providers, |
- base::Bind(&DiscoveryRequest::ReceivedSerials, this))); |
+ device_manager->QueryDevices( |
+ base::Bind(&DiscoveryRequest::ReceivedDevices, this)); |
} |
DiscoveryRequest::~DiscoveryRequest() { |
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
} |
-void DiscoveryRequest::ReceivedSerials( |
- const std::vector<std::string>& serials) { |
- DCHECK_EQ(device_message_loop_, base::MessageLoop::current()); |
- serials_ = serials; |
- ProcessSerials(); |
+void DiscoveryRequest::ReceivedDevices(const Devices& devices) { |
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
+ devices_ = devices; |
+ ProcessDevices(); |
} |
-void DiscoveryRequest::ProcessSerials() { |
- DCHECK_EQ(device_message_loop_, base::MessageLoop::current()); |
- if (serials_.size() == 0) { |
- BrowserThread::PostTask( |
- BrowserThread::UI, FROM_HERE, |
- base::Bind(&DiscoveryRequest::Respond, this)); |
+void DiscoveryRequest::ProcessDevices() { |
+ if (devices_.size() == 0) { |
+ Respond(); |
return; |
} |
- if (device_manager_->IsConnected(current_serial())) { |
- device_manager_->QueryDeviceInfo(current_serial(), |
- base::Bind(&DiscoveryRequest::ReceivedDeviceInfo, this)); |
- } else { |
- AndroidDeviceManager::DeviceInfo offline_info; |
- offline_info.model = kModelOffline; |
- remote_devices_->push_back(new DevToolsAndroidBridge::RemoteDevice( |
- android_bridge_, current_serial(), offline_info, false)); |
- NextDevice(); |
- } |
+ current_device()->QueryDeviceInfo( |
+ base::Bind(&DiscoveryRequest::ReceivedDeviceInfo, this)); |
} |
void DiscoveryRequest::ReceivedDeviceInfo( |
const AndroidDeviceManager::DeviceInfo& device_info) { |
- remote_devices_->push_back(new DevToolsAndroidBridge::RemoteDevice( |
- android_bridge_, current_serial(), device_info, true)); |
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
+ remote_devices_->push_back( |
+ new DevToolsAndroidBridge::RemoteDevice(current_device(), device_info)); |
browsers_ = remote_devices_->back()->browsers(); |
ProcessSockets(); |
} |
void DiscoveryRequest::ProcessSockets() { |
- DCHECK_EQ(device_message_loop_, base::MessageLoop::current()); |
if (browsers_.size() == 0) { |
NextDevice(); |
return; |
} |
- device_manager_->HttpQuery( |
- current_serial(), |
+ current_device()->SendJsonRequest( |
current_browser()->socket(), |
kVersionRequest, |
base::Bind(&DiscoveryRequest::ReceivedVersion, this)); |
@@ -183,7 +156,7 @@ void DiscoveryRequest::ProcessSockets() { |
void DiscoveryRequest::ReceivedVersion(int result, |
const std::string& response) { |
- DCHECK_EQ(device_message_loop_, base::MessageLoop::current()); |
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
if (result < 0) { |
NextBrowser(); |
return; |
@@ -210,8 +183,7 @@ void DiscoveryRequest::ReceivedVersion(int result, |
} |
} |
- device_manager_->HttpQuery( |
- current_serial(), |
+ current_device()->SendJsonRequest( |
current_browser()->socket(), |
kPageListRequest, |
base::Bind(&DiscoveryRequest::ReceivedPages, this)); |
@@ -219,7 +191,7 @@ void DiscoveryRequest::ReceivedVersion(int result, |
void DiscoveryRequest::ReceivedPages(int result, |
const std::string& response) { |
- DCHECK_EQ(device_message_loop_, base::MessageLoop::current()); |
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
if (result >= 0) { |
scoped_ptr<base::Value> value(base::JSONReader::Read(response)); |
base::ListValue* list_value; |
@@ -235,12 +207,12 @@ void DiscoveryRequest::NextBrowser() { |
} |
void DiscoveryRequest::NextDevice() { |
- serials_.pop_back(); |
- ProcessSerials(); |
+ devices_.pop_back(); |
+ ProcessDevices(); |
} |
void DiscoveryRequest::Respond() { |
- callback_.Run(remote_devices_.release()); |
+ callback_.Run(remote_devices_.Pass()); |
} |
// ProtocolCommand ------------------------------------------------------------ |
@@ -588,11 +560,9 @@ void RemotePageTarget::Navigate(const std::string& url, |
// DevToolsAndroidBridge::RemoteBrowser --------------------------------------- |
DevToolsAndroidBridge::RemoteBrowser::RemoteBrowser( |
- scoped_refptr<DevToolsAndroidBridge> android_bridge, |
- const std::string& serial, |
+ scoped_refptr<Device> device, |
const AndroidDeviceManager::BrowserInfo& browser_info) |
- : android_bridge_(android_bridge), |
- serial_(serial), |
+ : device_(device), |
socket_(browser_info.socket_name), |
display_name_(browser_info.display_name), |
type_(browser_info.type), |
@@ -642,7 +612,7 @@ void DevToolsAndroidBridge::RemoteBrowser::SetPageDescriptors( |
} |
static void RespondOnUIThread( |
- const DevToolsAndroidBridge::RemoteBrowser::JsonRequestCallback& callback, |
+ const DevToolsAndroidBridge::JsonRequestCallback& callback, |
int result, |
const std::string& response) { |
if (callback.is_null()) |
@@ -653,12 +623,7 @@ static void RespondOnUIThread( |
void DevToolsAndroidBridge::RemoteBrowser::SendJsonRequest( |
const std::string& request, const JsonRequestCallback& callback) { |
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
- android_bridge_->device_message_loop()->PostTask( |
- FROM_HERE, |
- base::Bind(&AndroidDeviceManager::HttpQuery, |
- android_bridge_->device_manager(), serial_, socket_, request, |
- base::Bind(&RespondOnUIThread, callback))); |
+ device_->SendJsonRequest(socket_, request, callback); |
} |
void DevToolsAndroidBridge::RemoteBrowser::SendProtocolCommand( |
@@ -684,7 +649,14 @@ void DevToolsAndroidBridge::RemoteBrowser::Open( |
scoped_refptr<content::DevToolsAgentHost> |
DevToolsAndroidBridge::RemoteBrowser::GetAgentHost() { |
return AgentHostDelegate::GetOrCreateAgentHost( |
- "adb:" + serial_ + ":" + socket_, this, kBrowserTargetSocket); |
+ "adb:" + device_->serial() + ":" + socket_, this, kBrowserTargetSocket); |
+} |
+ |
+scoped_refptr<DevToolsAndroidBridge::AndroidWebSocket> |
+DevToolsAndroidBridge::RemoteBrowser::CreateWebSocket( |
+ const std::string& url, |
+ DevToolsAndroidBridge::AndroidWebSocket::Delegate* delegate) { |
+ return device_->CreateWebSocket(socket_, url, delegate); |
} |
void DevToolsAndroidBridge::RemoteBrowser::RespondToOpenOnUIThread( |
@@ -764,113 +736,50 @@ void DevToolsAndroidBridge::RemoteBrowser::NavigatePageOnUIThread( |
DevToolsAndroidBridge::RemoteBrowser::~RemoteBrowser() { |
} |
- |
// DevToolsAndroidBridge::RemoteDevice ---------------------------------------- |
DevToolsAndroidBridge::RemoteDevice::RemoteDevice( |
- scoped_refptr<DevToolsAndroidBridge> android_bridge, |
- const std::string& serial, |
- const AndroidDeviceManager::DeviceInfo& device_info, |
- bool connected) |
- : android_bridge_(android_bridge), |
- serial_(serial), |
+ scoped_refptr<AndroidDeviceManager::Device> device, |
+ const AndroidDeviceManager::DeviceInfo& device_info) |
+ : device_(device), |
model_(device_info.model), |
- connected_(connected), |
+ connected_(device_info.connected), |
screen_size_(device_info.screen_size) { |
for (std::vector<AndroidDeviceManager::BrowserInfo>::const_iterator it = |
device_info.browser_info.begin(); |
it != device_info.browser_info.end(); |
++it) { |
- browsers_.push_back(new DevToolsAndroidBridge::RemoteBrowser( |
- android_bridge_, serial_, *it)); |
+ browsers_.push_back(new DevToolsAndroidBridge::RemoteBrowser(device, *it)); |
} |
} |
void DevToolsAndroidBridge::RemoteDevice::OpenSocket( |
const std::string& socket_name, |
const AndroidDeviceManager::SocketCallback& callback) { |
- android_bridge_->device_message_loop()->PostTask(FROM_HERE, |
- base::Bind(&AndroidDeviceManager::OpenSocket, |
- android_bridge_->device_manager(), |
- serial_, |
- socket_name, |
- callback)); |
+ device_->OpenSocket(socket_name, callback); |
} |
DevToolsAndroidBridge::RemoteDevice::~RemoteDevice() { |
} |
-// DevToolsAndroidBridge::HandlerThread --------------------------------- |
- |
-const char kDevToolsAdbBridgeThreadName[] = "Chrome_DevToolsADBThread"; |
- |
-DevToolsAndroidBridge::HandlerThread* |
-DevToolsAndroidBridge::HandlerThread::instance_ = NULL; |
- |
-// static |
-scoped_refptr<DevToolsAndroidBridge::HandlerThread> |
-DevToolsAndroidBridge::HandlerThread::GetInstance() { |
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
- if (!instance_) |
- new HandlerThread(); |
- return instance_; |
-} |
- |
-DevToolsAndroidBridge::HandlerThread::HandlerThread() { |
- instance_ = this; |
- thread_ = new base::Thread(kDevToolsAdbBridgeThreadName); |
- base::Thread::Options options; |
- options.message_loop_type = base::MessageLoop::TYPE_IO; |
- if (!thread_->StartWithOptions(options)) { |
- delete thread_; |
- thread_ = NULL; |
- } |
-} |
- |
-base::MessageLoop* DevToolsAndroidBridge::HandlerThread::message_loop() { |
- return thread_ ? thread_->message_loop() : NULL; |
-} |
- |
-// static |
-void DevToolsAndroidBridge::HandlerThread::StopThread( |
- base::Thread* thread) { |
- thread->Stop(); |
-} |
- |
-DevToolsAndroidBridge::HandlerThread::~HandlerThread() { |
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
- instance_ = NULL; |
- if (!thread_) |
- return; |
- // Shut down thread on FILE thread to join into IO. |
- BrowserThread::PostTask( |
- BrowserThread::FILE, FROM_HERE, |
- base::Bind(&HandlerThread::StopThread, thread_)); |
-} |
- |
// DevToolsAndroidBridge ------------------------------------------------------ |
DevToolsAndroidBridge::DevToolsAndroidBridge(Profile* profile) |
: profile_(profile), |
- handler_thread_(HandlerThread::GetInstance()) { |
+ device_manager_(AndroidDeviceManager::Create()) { |
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
pref_change_registrar_.Init(profile_->GetPrefs()); |
pref_change_registrar_.Add(prefs::kDevToolsDiscoverUsbDevicesEnabled, |
base::Bind(&DevToolsAndroidBridge::CreateDeviceProviders, |
base::Unretained(this))); |
CreateDeviceProviders(); |
- base::PostTaskAndReplyWithResult( |
- device_message_loop()->message_loop_proxy(), |
- FROM_HERE, |
- base::Bind(&AndroidDeviceManager::Create), |
- base::Bind(&DevToolsAndroidBridge::CreatedDeviceManager, this)); |
} |
void DevToolsAndroidBridge::AddDeviceListListener( |
DeviceListListener* listener) { |
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
device_list_listeners_.push_back(listener); |
- if (device_list_listeners_.size() == 1 && device_manager_) |
+ if (device_list_listeners_.size() == 1) |
RequestDeviceList(); |
} |
@@ -881,16 +790,14 @@ void DevToolsAndroidBridge::RemoveDeviceListListener( |
device_list_listeners_.begin(), device_list_listeners_.end(), listener); |
DCHECK(it != device_list_listeners_.end()); |
device_list_listeners_.erase(it); |
- if (device_list_listeners_.empty() && device_manager_) { |
- device_message_loop()->PostTask(FROM_HERE, |
- base::Bind(&AndroidDeviceManager::Stop, device_manager_)); |
- } |
+ if (device_list_listeners_.empty()) |
+ devices_.clear(); |
} |
void DevToolsAndroidBridge::AddDeviceCountListener( |
DeviceCountListener* listener) { |
device_count_listeners_.push_back(listener); |
- if (device_count_listeners_.size() == 1 && device_manager_) |
+ if (device_count_listeners_.size() == 1) |
RequestDeviceCount(); |
} |
@@ -913,47 +820,28 @@ DevToolsAndroidBridge::~DevToolsAndroidBridge() { |
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
DCHECK(device_list_listeners_.empty()); |
DCHECK(device_count_listeners_.empty()); |
- if (device_manager_) { |
- AndroidDeviceManager* raw_ptr = device_manager_.get(); |
- device_manager_->AddRef(); |
- device_manager_ = NULL; |
- device_message_loop()->ReleaseSoon(FROM_HERE, raw_ptr); |
- } |
} |
void DevToolsAndroidBridge::RequestDeviceList() { |
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
- DCHECK(device_manager_); |
if (device_list_listeners_.empty()) |
return; |
new DiscoveryRequest( |
- this, |
- device_manager(), |
- device_message_loop(), |
- device_providers_, |
+ device_manager_.get(), |
base::Bind(&DevToolsAndroidBridge::ReceivedDeviceList, this)); |
} |
-void DevToolsAndroidBridge::CreatedDeviceManager( |
- scoped_refptr<AndroidDeviceManager> device_manager) { |
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
- device_manager_ = device_manager; |
- if (!device_list_listeners_.empty()) |
- RequestDeviceList(); |
- if (!device_count_listeners_.empty()) |
- RequestDeviceCount(); |
-} |
- |
-void DevToolsAndroidBridge::ReceivedDeviceList(RemoteDevices* devices_ptr) { |
+void DevToolsAndroidBridge::ReceivedDeviceList( |
+ scoped_ptr<RemoteDevices> devices) { |
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
- scoped_ptr<RemoteDevices> devices(devices_ptr); |
- |
if (device_list_listeners_.empty()) |
return; |
+ devices_ = *devices; |
+ |
DeviceListListeners copy(device_list_listeners_); |
for (DeviceListListeners::iterator it = copy.begin(); it != copy.end(); ++it) |
(*it)->DeviceListChanged(*devices.get()); |
@@ -967,7 +855,6 @@ void DevToolsAndroidBridge::ReceivedDeviceList(RemoteDevices* devices_ptr) { |
void DevToolsAndroidBridge::RequestDeviceCount() { |
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
- DCHECK(device_manager_); |
if (device_count_listeners_.empty()) |
return; |
@@ -994,15 +881,15 @@ void DevToolsAndroidBridge::ReceivedDeviceCount(int count) { |
} |
void DevToolsAndroidBridge::CreateDeviceProviders() { |
- device_providers_.clear(); |
+ AndroidDeviceManager::DeviceProviders device_providers; |
#if defined(DEBUG_DEVTOOLS) |
BrowserListTabContentsProvider::EnableTethering(); |
// We cannot rely on command line switch here as we might want to connect |
// to another instance of Chrome. Using hard-coded port number instead. |
const int kDefaultDebuggingPort = 9222; |
- device_providers_.push_back(new SelfAsDeviceProvider(kDefaultDebuggingPort)); |
+ device_providers.push_back(new SelfAsDeviceProvider(kDefaultDebuggingPort)); |
#endif |
- device_providers_.push_back(new AdbDeviceProvider()); |
+ device_providers.push_back(new AdbDeviceProvider()); |
PrefService* service = profile_->GetPrefs(); |
const PrefService::Preference* pref = |
@@ -1011,6 +898,7 @@ void DevToolsAndroidBridge::CreateDeviceProviders() { |
bool enabled; |
if (pref_value->GetAsBoolean(&enabled) && enabled) { |
- device_providers_.push_back(new UsbDeviceProvider(profile_)); |
+ device_providers.push_back(new UsbDeviceProvider(profile_)); |
} |
+ device_manager_->SetDeviceProviders(device_providers); |
} |