OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/devtools/chrome_devtools_manager_delegate.h" | 5 #include "chrome/browser/devtools/chrome_devtools_manager_delegate.h" |
6 | 6 |
7 #include "base/memory/ptr_util.h" | 7 #include "base/memory/ptr_util.h" |
8 #include "base/strings/utf_string_conversions.h" | 8 #include "base/strings/utf_string_conversions.h" |
9 #include "build/build_config.h" | 9 #include "build/build_config.h" |
10 #include "chrome/browser/devtools/device/android_device_manager.h" | 10 #include "chrome/browser/devtools/device/android_device_manager.h" |
(...skipping 22 matching lines...) Expand all Loading... |
33 | 33 |
34 char ChromeDevToolsManagerDelegate::kTypeApp[] = "app"; | 34 char ChromeDevToolsManagerDelegate::kTypeApp[] = "app"; |
35 char ChromeDevToolsManagerDelegate::kTypeBackgroundPage[] = "background_page"; | 35 char ChromeDevToolsManagerDelegate::kTypeBackgroundPage[] = "background_page"; |
36 char ChromeDevToolsManagerDelegate::kTypeWebView[] = "webview"; | 36 char ChromeDevToolsManagerDelegate::kTypeWebView[] = "webview"; |
37 | 37 |
38 char kLocationsParam[] = "locations"; | 38 char kLocationsParam[] = "locations"; |
39 char kHostParam[] = "host"; | 39 char kHostParam[] = "host"; |
40 char kPortParam[] = "port"; | 40 char kPortParam[] = "port"; |
41 | 41 |
42 ChromeDevToolsManagerDelegate::ChromeDevToolsManagerDelegate() | 42 ChromeDevToolsManagerDelegate::ChromeDevToolsManagerDelegate() |
43 : network_protocol_handler_(new DevToolsNetworkProtocolHandler()) { | 43 : network_protocol_handler_(new DevToolsNetworkProtocolHandler()), |
| 44 remote_locations_requester_(nullptr) { |
| 45 content::DevToolsAgentHost::AddObserver(this); |
44 } | 46 } |
45 | 47 |
46 ChromeDevToolsManagerDelegate::~ChromeDevToolsManagerDelegate() { | 48 ChromeDevToolsManagerDelegate::~ChromeDevToolsManagerDelegate() { |
| 49 content::DevToolsAgentHost::RemoveObserver(this); |
47 } | 50 } |
48 | 51 |
49 void ChromeDevToolsManagerDelegate::Inspect( | 52 void ChromeDevToolsManagerDelegate::Inspect( |
50 content::DevToolsAgentHost* agent_host) { | 53 content::DevToolsAgentHost* agent_host) { |
51 DevToolsWindow::OpenDevToolsWindow(agent_host, nullptr); | 54 DevToolsWindow::OpenDevToolsWindow(agent_host, nullptr); |
52 } | 55 } |
53 | 56 |
54 void ChromeDevToolsManagerDelegate::DevicesAvailable( | 57 void ChromeDevToolsManagerDelegate::DevicesAvailable( |
55 const DevToolsAgentHost::DiscoveryCallback& callback, | |
56 const DevToolsDeviceDiscovery::CompleteDevices& devices) { | 58 const DevToolsDeviceDiscovery::CompleteDevices& devices) { |
57 DevToolsAgentHost::List result = DevToolsAgentHost::GetOrCreateAll(); | 59 DevToolsAgentHost::List remote_targets; |
58 for (const auto& complete : devices) { | 60 for (const auto& complete : devices) { |
59 for (const auto& browser : complete.second->browsers()) { | 61 for (const auto& browser : complete.second->browsers()) { |
60 for (const auto& page : browser->pages()) | 62 for (const auto& page : browser->pages()) |
61 result.push_back(page->CreateTarget()); | 63 remote_targets.push_back(page->CreateTarget()); |
62 } | 64 } |
63 } | 65 } |
64 callback.Run(std::move(result)); | 66 remote_agent_hosts_.swap(remote_targets); |
65 } | |
66 | |
67 bool ChromeDevToolsManagerDelegate::DiscoverTargets( | |
68 const DevToolsAgentHost::DiscoveryCallback& callback) { | |
69 if (!tcp_locations_.size()) | |
70 return false; | |
71 | |
72 if (!device_manager_) | |
73 device_manager_ = AndroidDeviceManager::Create(); | |
74 | |
75 AndroidDeviceManager::DeviceProviders providers; | |
76 providers.push_back(new TCPDeviceProvider(tcp_locations_)); | |
77 device_manager_->SetDeviceProviders(providers); | |
78 | |
79 DevToolsDeviceDiscovery::DiscoverOnce( | |
80 device_manager_.get(), | |
81 base::Bind(&ChromeDevToolsManagerDelegate::DevicesAvailable, | |
82 base::Unretained(this), | |
83 callback)); | |
84 return true; | |
85 } | 67 } |
86 | 68 |
87 base::DictionaryValue* ChromeDevToolsManagerDelegate::HandleCommand( | 69 base::DictionaryValue* ChromeDevToolsManagerDelegate::HandleCommand( |
88 DevToolsAgentHost* agent_host, | 70 DevToolsAgentHost* agent_host, |
89 base::DictionaryValue* command_dict) { | 71 base::DictionaryValue* command_dict) { |
90 | 72 |
91 int id = 0; | 73 int id = 0; |
92 std::string method; | 74 std::string method; |
93 base::DictionaryValue* params = nullptr; | 75 base::DictionaryValue* params = nullptr; |
94 if (!DevToolsProtocol::ParseCommand(command_dict, &id, &method, ¶ms)) | 76 if (!DevToolsProtocol::ParseCommand(command_dict, &id, &method, ¶ms)) |
95 return nullptr; | 77 return nullptr; |
96 | 78 |
97 if (method == chrome::devtools::Browser::setRemoteLocations::kName) | 79 if (method == chrome::devtools::Target::setRemoteLocations::kName) |
98 return SetRemoteLocations(agent_host, id, params).release(); | 80 return SetRemoteLocations(agent_host, id, params).release(); |
99 | 81 |
100 return network_protocol_handler_->HandleCommand(agent_host, command_dict); | 82 return network_protocol_handler_->HandleCommand(agent_host, command_dict); |
101 } | 83 } |
102 | 84 |
103 std::string ChromeDevToolsManagerDelegate::GetTargetType( | 85 std::string ChromeDevToolsManagerDelegate::GetTargetType( |
104 content::RenderFrameHost* host) { | 86 content::RenderFrameHost* host) { |
105 content::WebContents* web_contents = | 87 content::WebContents* web_contents = |
106 content::WebContents::FromRenderFrameHost(host); | 88 content::WebContents::FromRenderFrameHost(host); |
107 | 89 |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
184 return content::DevToolsFrontendHost::GetFrontendResource(path).as_string(); | 166 return content::DevToolsFrontendHost::GetFrontendResource(path).as_string(); |
185 } | 167 } |
186 | 168 |
187 void ChromeDevToolsManagerDelegate::DevToolsAgentHostAttached( | 169 void ChromeDevToolsManagerDelegate::DevToolsAgentHostAttached( |
188 content::DevToolsAgentHost* agent_host) { | 170 content::DevToolsAgentHost* agent_host) { |
189 network_protocol_handler_->DevToolsAgentStateChanged(agent_host, true); | 171 network_protocol_handler_->DevToolsAgentStateChanged(agent_host, true); |
190 } | 172 } |
191 | 173 |
192 void ChromeDevToolsManagerDelegate::DevToolsAgentHostDetached( | 174 void ChromeDevToolsManagerDelegate::DevToolsAgentHostDetached( |
193 content::DevToolsAgentHost* agent_host) { | 175 content::DevToolsAgentHost* agent_host) { |
| 176 if (agent_host == remote_locations_requester_) { |
| 177 remote_locations_requester_ = nullptr; |
| 178 device_discovery_.reset(); |
| 179 remote_agent_hosts_.clear(); |
| 180 } |
194 network_protocol_handler_->DevToolsAgentStateChanged(agent_host, false); | 181 network_protocol_handler_->DevToolsAgentStateChanged(agent_host, false); |
195 } | 182 } |
196 | 183 |
197 std::unique_ptr<base::DictionaryValue> | 184 std::unique_ptr<base::DictionaryValue> |
198 ChromeDevToolsManagerDelegate::SetRemoteLocations( | 185 ChromeDevToolsManagerDelegate::SetRemoteLocations( |
199 content::DevToolsAgentHost* agent_host, | 186 content::DevToolsAgentHost* agent_host, |
200 int command_id, | 187 int command_id, |
201 base::DictionaryValue* params) { | 188 base::DictionaryValue* params) { |
202 tcp_locations_.clear(); | 189 if (remote_locations_requester_) { |
| 190 return DevToolsProtocol::CreateInvalidParamsResponse( |
| 191 command_id, |
| 192 "Remote locations are already in use by another client."); |
| 193 } |
203 | 194 |
| 195 remote_locations_requester_ = agent_host; |
| 196 std::set<net::HostPortPair> tcp_locations; |
204 base::ListValue* locations; | 197 base::ListValue* locations; |
205 if (!params->GetList(kLocationsParam, &locations)) | 198 if (!params->GetList(kLocationsParam, &locations)) |
206 return DevToolsProtocol::CreateInvalidParamsResponse(command_id, | 199 return DevToolsProtocol::CreateInvalidParamsResponse(command_id, |
207 kLocationsParam); | 200 kLocationsParam); |
208 for (const auto& item : *locations) { | 201 for (const auto& item : *locations) { |
209 if (!item->IsType(base::Value::TYPE_DICTIONARY)) { | 202 if (!item->IsType(base::Value::TYPE_DICTIONARY)) { |
210 return DevToolsProtocol::CreateInvalidParamsResponse(command_id, | 203 return DevToolsProtocol::CreateInvalidParamsResponse(command_id, |
211 kLocationsParam); | 204 kLocationsParam); |
212 } | 205 } |
213 base::DictionaryValue* dictionary = | 206 base::DictionaryValue* dictionary = |
214 static_cast<base::DictionaryValue*>(item.get()); | 207 static_cast<base::DictionaryValue*>(item.get()); |
215 std::string host; | 208 std::string host; |
216 if (!dictionary->GetStringWithoutPathExpansion(kHostParam, &host)) { | 209 if (!dictionary->GetStringWithoutPathExpansion(kHostParam, &host)) { |
217 return DevToolsProtocol::CreateInvalidParamsResponse(command_id, | 210 return DevToolsProtocol::CreateInvalidParamsResponse(command_id, |
218 kLocationsParam); | 211 kLocationsParam); |
219 } | 212 } |
220 int port = 0; | 213 int port = 0; |
221 if (!dictionary->GetIntegerWithoutPathExpansion(kPortParam, &port)) { | 214 if (!dictionary->GetIntegerWithoutPathExpansion(kPortParam, &port)) { |
222 return DevToolsProtocol::CreateInvalidParamsResponse(command_id, | 215 return DevToolsProtocol::CreateInvalidParamsResponse(command_id, |
223 kLocationsParam); | 216 kLocationsParam); |
224 } | 217 } |
225 tcp_locations_.insert(net::HostPortPair(host, port)); | 218 tcp_locations.insert(net::HostPortPair(host, port)); |
226 } | 219 } |
| 220 |
| 221 if (tcp_locations.empty()) { |
| 222 device_discovery_.reset(); |
| 223 remote_agent_hosts_.clear(); |
| 224 } else { |
| 225 if (!device_manager_) |
| 226 device_manager_ = AndroidDeviceManager::Create(); |
| 227 |
| 228 AndroidDeviceManager::DeviceProviders providers; |
| 229 providers.push_back(new TCPDeviceProvider(tcp_locations)); |
| 230 device_manager_->SetDeviceProviders(providers); |
| 231 |
| 232 device_discovery_.reset(new DevToolsDeviceDiscovery(device_manager_.get(), |
| 233 base::Bind(&ChromeDevToolsManagerDelegate::DevicesAvailable, |
| 234 base::Unretained(this)))); |
| 235 } |
| 236 |
227 std::unique_ptr<base::DictionaryValue> result( | 237 std::unique_ptr<base::DictionaryValue> result( |
228 base::MakeUnique<base::DictionaryValue>()); | 238 base::MakeUnique<base::DictionaryValue>()); |
229 return DevToolsProtocol::CreateSuccessResponse(command_id, std::move(result)); | 239 return DevToolsProtocol::CreateSuccessResponse(command_id, std::move(result)); |
230 } | 240 } |
OLD | NEW |