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/device/webrtc/webrtc_device_provider.h" | 5 #include "chrome/browser/devtools/device/webrtc/webrtc_device_provider.h" |
6 | 6 |
| 7 #include "chrome/browser/chrome_notification_types.h" |
| 8 #include "chrome/browser/signin/profile_identity_provider.h" |
7 #include "chrome/browser/ui/browser.h" | 9 #include "chrome/browser/ui/browser.h" |
8 #include "chrome/common/url_constants.h" | 10 #include "chrome/common/url_constants.h" |
| 11 #include "content/public/browser/notification_observer.h" |
| 12 #include "content/public/browser/notification_registrar.h" |
| 13 #include "content/public/browser/notification_source.h" |
9 #include "content/public/browser/web_contents.h" | 14 #include "content/public/browser/web_contents.h" |
10 #include "content/public/browser/web_ui_data_source.h" | 15 #include "content/public/browser/web_ui_data_source.h" |
11 #include "content/public/browser/web_ui_message_handler.h" | 16 #include "content/public/browser/web_ui_message_handler.h" |
12 #include "grit/webrtc_device_provider_resources_map.h" | 17 #include "grit/webrtc_device_provider_resources_map.h" |
| 18 #include "net/base/net_errors.h" |
| 19 #include "net/socket/stream_socket.h" |
13 #include "ui/base/page_transition_types.h" | 20 #include "ui/base/page_transition_types.h" |
14 | 21 |
| 22 using content::BrowserThread; |
| 23 using content::NotificationDetails; |
| 24 using content::NotificationObserver; |
| 25 using content::NotificationRegistrar; |
| 26 using content::NotificationSource; |
| 27 using content::WebContents; |
| 28 using content::WebUIDataSource; |
| 29 using content::WebUIMessageHandler; |
| 30 |
| 31 namespace { |
| 32 |
15 const char kBackgroundWorkerURL[] = | 33 const char kBackgroundWorkerURL[] = |
16 "chrome://webrtc-device-provider/background_worker.html"; | 34 "chrome://webrtc-device-provider/background_worker.html"; |
17 | 35 |
18 namespace { | 36 } // namespace |
19 | 37 |
20 class MessageHandler : public content::WebUIMessageHandler { | 38 // Lives on the UI thread. |
| 39 class WebRTCDeviceProvider::DevToolsBridgeClient : |
| 40 private NotificationObserver, |
| 41 private IdentityProvider::Observer { |
21 public: | 42 public: |
22 explicit MessageHandler(WebRTCDeviceProvider* owner); | 43 static base::WeakPtr<DevToolsBridgeClient> Create( |
| 44 Profile* profile, |
| 45 SigninManagerBase* signin_manager, |
| 46 ProfileOAuth2TokenService* token_service); |
| 47 |
| 48 void DeleteSelf(); |
| 49 |
| 50 private: |
| 51 DevToolsBridgeClient(Profile* profile, |
| 52 SigninManagerBase* signin_manager, |
| 53 ProfileOAuth2TokenService* token_service); |
| 54 |
| 55 ~DevToolsBridgeClient(); |
| 56 |
| 57 void CreateBackgroundWorker(); |
| 58 |
| 59 // Implementation of IdentityProvider::Observer. |
| 60 void OnActiveAccountLogin() override; |
| 61 void OnActiveAccountLogout() override; |
| 62 |
| 63 // Implementation of NotificationObserver. |
| 64 void Observe(int type, |
| 65 const NotificationSource& source, |
| 66 const NotificationDetails& details) override; |
| 67 |
| 68 Profile* const profile_; |
| 69 ProfileIdentityProvider identity_provider_; |
| 70 NotificationRegistrar registrar_; |
| 71 scoped_ptr<WebContents> background_worker_; |
| 72 base::WeakPtrFactory<DevToolsBridgeClient> weak_factory_; |
| 73 }; |
| 74 |
| 75 class WebRTCDeviceProvider::MessageHandler : public WebUIMessageHandler { |
| 76 public: |
| 77 explicit MessageHandler(DevToolsBridgeClient* owner); |
23 | 78 |
24 void RegisterMessages() override; | 79 void RegisterMessages() override; |
25 | 80 |
26 private: | 81 private: |
27 void HandleLoaded(const base::ListValue* args); | 82 void HandleLoaded(const base::ListValue* args); |
28 | 83 |
29 WebRTCDeviceProvider* const owner_; | 84 DevToolsBridgeClient* const owner_; |
30 }; | 85 }; |
31 | 86 |
32 // MessageHandler ------------------------------------------------------------- | 87 // WebRTCDeviceProvider::WebUI ------------------------------------------------- |
33 | |
34 MessageHandler::MessageHandler( | |
35 WebRTCDeviceProvider* owner) : owner_(owner) { | |
36 } | |
37 | |
38 void MessageHandler::RegisterMessages() { | |
39 web_ui()->RegisterMessageCallback( | |
40 "loaded", | |
41 base::Bind(&MessageHandler::HandleLoaded, base::Unretained(this))); | |
42 } | |
43 | |
44 void MessageHandler::HandleLoaded( | |
45 const base::ListValue* args) { | |
46 if (!owner_) | |
47 return; | |
48 // TODO(serya): implement | |
49 } | |
50 | |
51 } // namespace | |
52 | |
53 // WebRTCDeviceProvider::WebUI ------------------------------------------------ | |
54 | 88 |
55 WebRTCDeviceProvider::WebUI::WebUI(content::WebUI* web_ui) | 89 WebRTCDeviceProvider::WebUI::WebUI(content::WebUI* web_ui) |
56 : content::WebUIController(web_ui) { | 90 : content::WebUIController(web_ui) { |
57 Profile* profile = Profile::FromWebUI(web_ui); | 91 Profile* profile = Profile::FromWebUI(web_ui); |
58 | 92 |
59 content::WebUIDataSource* source = content::WebUIDataSource::Create( | 93 WebUIDataSource* source = WebUIDataSource::Create( |
60 chrome::kChromeUIWebRTCDeviceProviderHost); | 94 chrome::kChromeUIWebRTCDeviceProviderHost); |
61 | 95 |
62 for (size_t i = 0; i < kWebrtcDeviceProviderResourcesSize; i++) { | 96 for (size_t i = 0; i < kWebrtcDeviceProviderResourcesSize; i++) { |
63 source->AddResourcePath(kWebrtcDeviceProviderResources[i].name, | 97 source->AddResourcePath(kWebrtcDeviceProviderResources[i].name, |
64 kWebrtcDeviceProviderResources[i].value); | 98 kWebrtcDeviceProviderResources[i].value); |
65 } | 99 } |
66 | 100 |
67 // Sets a stub message handler. If web contents was created by | 101 // Sets a stub message handler. If web contents was created by |
68 // WebRTCDeviceProvider message callbacks will be overridden by | 102 // WebRTCDeviceProvider message callbacks will be overridden by |
69 // a real implementation. | 103 // a real implementation. |
70 web_ui->AddMessageHandler(new MessageHandler(nullptr)); | 104 web_ui->AddMessageHandler(new MessageHandler(nullptr)); |
71 | 105 |
72 content::WebUIDataSource::Add(profile, source); | 106 WebUIDataSource::Add(profile, source); |
73 } | 107 } |
74 | 108 |
75 WebRTCDeviceProvider::WebUI::~WebUI() { | 109 WebRTCDeviceProvider::WebUI::~WebUI() { |
76 } | 110 } |
77 | 111 |
78 // WebRTCDeviceProvider ------------------------------------------------------- | 112 // WebRTCDeviceProvider::DevToolsBridgeClient ---------------------------------- |
79 | 113 |
80 WebRTCDeviceProvider::WebRTCDeviceProvider(content::BrowserContext* context) { | 114 // static |
81 background_worker_.reset(content::WebContents::Create( | 115 base::WeakPtr<WebRTCDeviceProvider::DevToolsBridgeClient> |
82 content::WebContents::CreateParams(context))); | 116 WebRTCDeviceProvider::DevToolsBridgeClient::Create( |
| 117 Profile* profile, |
| 118 SigninManagerBase* signin_manager, |
| 119 ProfileOAuth2TokenService* token_service) { |
| 120 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| 121 auto instance = new DevToolsBridgeClient( |
| 122 profile, signin_manager, token_service); |
| 123 return instance->weak_factory_.GetWeakPtr(); |
| 124 } |
83 | 125 |
84 // TODO(serya): Make sure background_worker_ destructed before profile. | 126 WebRTCDeviceProvider::DevToolsBridgeClient::DevToolsBridgeClient( |
| 127 Profile* profile, |
| 128 SigninManagerBase* signin_manager, |
| 129 ProfileOAuth2TokenService* token_service) |
| 130 : profile_(profile), |
| 131 identity_provider_(signin_manager, token_service, nullptr), |
| 132 weak_factory_(this) { |
| 133 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| 134 |
| 135 identity_provider_.AddObserver(this); |
| 136 registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED, |
| 137 content::Source<Profile>(profile_)); |
| 138 |
| 139 if (!identity_provider_.GetActiveAccountId().empty()) |
| 140 CreateBackgroundWorker(); |
| 141 } |
| 142 |
| 143 WebRTCDeviceProvider::DevToolsBridgeClient::~DevToolsBridgeClient() { |
| 144 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| 145 |
| 146 identity_provider_.RemoveObserver(this); |
| 147 } |
| 148 |
| 149 void WebRTCDeviceProvider::DevToolsBridgeClient::DeleteSelf() { |
| 150 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| 151 delete this; |
| 152 } |
| 153 |
| 154 void WebRTCDeviceProvider::DevToolsBridgeClient::CreateBackgroundWorker() { |
| 155 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| 156 |
| 157 background_worker_.reset( |
| 158 WebContents::Create(WebContents::CreateParams(profile_))); |
| 159 |
85 GURL url(kBackgroundWorkerURL); | 160 GURL url(kBackgroundWorkerURL); |
86 | |
87 DCHECK_EQ(chrome::kChromeUIWebRTCDeviceProviderHost, url.host()); | 161 DCHECK_EQ(chrome::kChromeUIWebRTCDeviceProviderHost, url.host()); |
88 | 162 |
89 background_worker_->GetController().LoadURL( | 163 background_worker_->GetController().LoadURL( |
90 url, | 164 url, |
91 content::Referrer(), | 165 content::Referrer(), |
92 ui::PAGE_TRANSITION_AUTO_TOPLEVEL, | 166 ui::PAGE_TRANSITION_AUTO_TOPLEVEL, |
93 std::string()); | 167 std::string()); |
94 | 168 |
95 background_worker_->GetWebUI()->AddMessageHandler( | 169 background_worker_->GetWebUI()->AddMessageHandler( |
96 new MessageHandler(this)); | 170 new MessageHandler(this)); |
97 } | 171 } |
98 | 172 |
| 173 void WebRTCDeviceProvider::DevToolsBridgeClient::Observe( |
| 174 int type, |
| 175 const NotificationSource& source, |
| 176 const NotificationDetails& details) { |
| 177 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| 178 DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type); |
| 179 |
| 180 delete this; |
| 181 } |
| 182 |
| 183 void WebRTCDeviceProvider::DevToolsBridgeClient::OnActiveAccountLogin() { |
| 184 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| 185 CreateBackgroundWorker(); |
| 186 } |
| 187 |
| 188 void WebRTCDeviceProvider::DevToolsBridgeClient::OnActiveAccountLogout() { |
| 189 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| 190 background_worker_.reset(); |
| 191 } |
| 192 |
| 193 // WebRTCDeviceProvider::MessageHandler ---------------------------------------- |
| 194 |
| 195 WebRTCDeviceProvider::MessageHandler::MessageHandler( |
| 196 DevToolsBridgeClient* owner) : owner_(owner) { |
| 197 } |
| 198 |
| 199 void WebRTCDeviceProvider::MessageHandler::RegisterMessages() { |
| 200 web_ui()->RegisterMessageCallback( |
| 201 "loaded", |
| 202 base::Bind(&MessageHandler::HandleLoaded, base::Unretained(this))); |
| 203 } |
| 204 |
| 205 void WebRTCDeviceProvider::MessageHandler::HandleLoaded( |
| 206 const base::ListValue* args) { |
| 207 if (!owner_) |
| 208 return; |
| 209 // TODO(serya): implement |
| 210 } |
| 211 |
| 212 // WebRTCDeviceProvider -------------------------------------------------------- |
| 213 |
| 214 WebRTCDeviceProvider::WebRTCDeviceProvider( |
| 215 Profile* profile, |
| 216 SigninManagerBase* signin_manager, |
| 217 ProfileOAuth2TokenService* token_service) |
| 218 : client_(DevToolsBridgeClient::Create( |
| 219 profile, signin_manager, token_service)) { |
| 220 } |
| 221 |
99 WebRTCDeviceProvider::~WebRTCDeviceProvider() { | 222 WebRTCDeviceProvider::~WebRTCDeviceProvider() { |
| 223 BrowserThread::PostTask( |
| 224 BrowserThread::UI, |
| 225 FROM_HERE, |
| 226 base::Bind(&DevToolsBridgeClient::DeleteSelf, client_)); |
100 } | 227 } |
101 | 228 |
102 void WebRTCDeviceProvider::QueryDevices(const SerialsCallback& callback) { | 229 void WebRTCDeviceProvider::QueryDevices(const SerialsCallback& callback) { |
103 // TODO(serya): Implement | 230 // TODO(serya): Implement |
| 231 base::MessageLoop::current()->PostTask( |
| 232 FROM_HERE, base::Bind(callback, std::vector<std::string>())); |
104 } | 233 } |
105 | 234 |
106 void WebRTCDeviceProvider::QueryDeviceInfo(const std::string& serial, | 235 void WebRTCDeviceProvider::QueryDeviceInfo(const std::string& serial, |
107 const DeviceInfoCallback& callback) { | 236 const DeviceInfoCallback& callback) { |
108 // TODO(serya): Implement | 237 // TODO(serya): Implement |
| 238 base::MessageLoop::current()->PostTask( |
| 239 FROM_HERE, base::Bind(callback, AndroidDeviceManager::DeviceInfo())); |
109 } | 240 } |
110 | 241 |
111 void WebRTCDeviceProvider::OpenSocket(const std::string& serial, | 242 void WebRTCDeviceProvider::OpenSocket(const std::string& serial, |
112 const std::string& socket_name, | 243 const std::string& socket_name, |
113 const SocketCallback& callback) { | 244 const SocketCallback& callback) { |
114 // TODO(serya): Implement | 245 // TODO(serya): Implement |
| 246 scoped_ptr<net::StreamSocket> socket; |
| 247 base::MessageLoop::current()->PostTask( |
| 248 FROM_HERE, base::Bind(callback, net::ERR_FAILED, base::Passed(&socket))); |
115 } | 249 } |
OLD | NEW |