OLD | NEW |
---|---|
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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 "blimp/engine/session/blimp_engine_session.h" | 5 #include "blimp/engine/session/blimp_engine_session.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/command_line.h" | 10 #include "base/command_line.h" |
(...skipping 118 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
129 // |net_log|: The log to use for network-related events. | 129 // |net_log|: The log to use for network-related events. |
130 // |quit_closure|: A closure which will terminate the engine when | 130 // |quit_closure|: A closure which will terminate the engine when |
131 // invoked. | 131 // invoked. |
132 EngineNetworkComponents(net::NetLog* net_log, | 132 EngineNetworkComponents(net::NetLog* net_log, |
133 const base::Closure& quit_closure); | 133 const base::Closure& quit_closure); |
134 ~EngineNetworkComponents() override; | 134 ~EngineNetworkComponents() override; |
135 | 135 |
136 // Sets up network components and starts listening for incoming connection. | 136 // Sets up network components and starts listening for incoming connection. |
137 // This should be called after all features have been registered so that | 137 // This should be called after all features have been registered so that |
138 // received messages can be properly handled. | 138 // received messages can be properly handled. |
139 void Initialize(const std::string& client_token); | 139 void Initialize(scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner, |
Wez
2016/08/19 19:15:50
nit: Consider replacing the quit_closure ctor para
Kevin M
2016/08/19 21:43:33
I just made NetworkComponents compute the quit clo
| |
140 base::WeakPtr<BlobChannelSender> blob_channel_sender, | |
141 const std::string& client_token); | |
140 | 142 |
141 uint16_t GetPortForTesting() { return port_; } | 143 uint16_t GetPortForTesting() { return port_; } |
142 | 144 |
143 BrowserConnectionHandler* GetBrowserConnectionHandler(); | 145 BrowserConnectionHandler* connection_handler() { |
146 return &connection_handler_; | |
147 } | |
148 | |
149 BlobChannelService* blob_channel_service() { | |
150 return blob_channel_service_.get(); | |
151 } | |
144 | 152 |
145 private: | 153 private: |
146 // ConnectionHandler implementation. | 154 // ConnectionHandler implementation. |
147 void HandleConnection(std::unique_ptr<BlimpConnection> connection) override; | 155 void HandleConnection(std::unique_ptr<BlimpConnection> connection) override; |
148 | 156 |
149 // ConnectionErrorObserver implementation. | 157 // ConnectionErrorObserver implementation. |
150 // Signals the engine session that an authenticated connection was | 158 // Signals the engine session that an authenticated connection was |
151 // terminated. | 159 // terminated. |
152 void OnConnectionError(int error) override; | 160 void OnConnectionError(int error) override; |
153 | 161 |
154 net::NetLog* net_log_; | 162 net::NetLog* net_log_; |
155 base::Closure quit_closure_; | 163 base::Closure quit_closure_; |
156 uint16_t port_ = 0; | 164 uint16_t port_ = 0; |
157 | 165 |
158 std::unique_ptr<BrowserConnectionHandler> connection_handler_; | 166 BrowserConnectionHandler connection_handler_; |
159 std::unique_ptr<EngineAuthenticationHandler> authentication_handler_; | 167 std::unique_ptr<EngineAuthenticationHandler> authentication_handler_; |
160 std::unique_ptr<EngineConnectionManager> connection_manager_; | 168 std::unique_ptr<EngineConnectionManager> connection_manager_; |
169 std::unique_ptr<BlobChannelService> blob_channel_service_; | |
161 | 170 |
162 DISALLOW_COPY_AND_ASSIGN(EngineNetworkComponents); | 171 DISALLOW_COPY_AND_ASSIGN(EngineNetworkComponents); |
163 }; | 172 }; |
164 | 173 |
165 EngineNetworkComponents::EngineNetworkComponents( | 174 EngineNetworkComponents::EngineNetworkComponents( |
166 net::NetLog* net_log, | 175 net::NetLog* net_log, |
167 const base::Closure& quit_closure) | 176 const base::Closure& quit_closure) |
168 : net_log_(net_log), | 177 : net_log_(net_log), |
169 quit_closure_(quit_closure), | 178 quit_closure_(quit_closure) {} |
170 connection_handler_(new BrowserConnectionHandler) {} | |
171 | 179 |
172 EngineNetworkComponents::~EngineNetworkComponents() { | 180 EngineNetworkComponents::~EngineNetworkComponents() { |
173 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); | 181 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
174 } | 182 } |
175 | 183 |
176 void EngineNetworkComponents::Initialize(const std::string& client_token) { | 184 void EngineNetworkComponents::Initialize( |
185 scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner, | |
186 base::WeakPtr<BlobChannelSender> blob_channel_sender, | |
187 const std::string& client_token) { | |
177 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); | 188 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
178 DCHECK(!connection_manager_); | 189 DCHECK(!connection_manager_); |
179 // Plumb authenticated connections from the authentication handler | 190 // Plumb authenticated connections from the authentication handler |
180 // to |this| (which will then pass it to |connection_handler_|. | 191 // to |this| (which will then pass it to |connection_handler_|. |
181 authentication_handler_ = | 192 authentication_handler_ = |
182 base::WrapUnique(new EngineAuthenticationHandler(this, client_token)); | 193 base::WrapUnique(new EngineAuthenticationHandler(this, client_token)); |
183 | 194 |
184 // Plumb unauthenticated connections to |authentication_handler_|. | 195 // Plumb unauthenticated connections to |authentication_handler_|. |
185 connection_manager_ = base::WrapUnique( | 196 connection_manager_ = base::WrapUnique( |
186 new EngineConnectionManager(authentication_handler_.get())); | 197 new EngineConnectionManager(authentication_handler_.get())); |
187 | 198 |
199 blob_channel_service_ = | |
200 base::MakeUnique<BlobChannelService>(blob_channel_sender, ui_task_runner); | |
201 | |
188 // Adds BlimpTransports to connection_manager_. | 202 // Adds BlimpTransports to connection_manager_. |
189 net::IPEndPoint address(GetIPv4AnyAddress(), GetListeningPort()); | 203 net::IPEndPoint address(GetIPv4AnyAddress(), GetListeningPort()); |
190 TCPEngineTransport* transport = new TCPEngineTransport(address, net_log_); | 204 TCPEngineTransport* transport = new TCPEngineTransport(address, net_log_); |
191 connection_manager_->AddTransport(base::WrapUnique(transport)); | 205 connection_manager_->AddTransport(base::WrapUnique(transport)); |
192 | 206 |
193 transport->GetLocalAddress(&address); | 207 transport->GetLocalAddress(&address); |
194 port_ = address.port(); | 208 port_ = address.port(); |
195 DVLOG(1) << "Engine port #: " << port_; | 209 DVLOG(1) << "Engine port #: " << port_; |
196 } | 210 } |
197 | 211 |
198 void EngineNetworkComponents::HandleConnection( | 212 void EngineNetworkComponents::HandleConnection( |
199 std::unique_ptr<BlimpConnection> connection) { | 213 std::unique_ptr<BlimpConnection> connection) { |
200 // Observe |connection| for disconnection events. | 214 // Observe |connection| for disconnection events. |
201 connection->AddConnectionErrorObserver(this); | 215 connection->AddConnectionErrorObserver(this); |
202 connection_handler_->HandleConnection(std::move(connection)); | 216 connection_handler_.HandleConnection(std::move(connection)); |
203 } | 217 } |
204 | 218 |
205 void EngineNetworkComponents::OnConnectionError(int error) { | 219 void EngineNetworkComponents::OnConnectionError(int error) { |
206 DVLOG(1) << "EngineNetworkComponents::OnConnectionError(" << error << ")"; | 220 DVLOG(1) << "EngineNetworkComponents::OnConnectionError(" << error << ")"; |
207 quit_closure_.Run(); | 221 quit_closure_.Run(); |
208 } | 222 } |
209 | 223 |
210 BrowserConnectionHandler* | |
211 EngineNetworkComponents::GetBrowserConnectionHandler() { | |
212 return connection_handler_.get(); | |
213 } | |
214 | |
215 BlimpEngineSession::BlimpEngineSession( | 224 BlimpEngineSession::BlimpEngineSession( |
216 std::unique_ptr<BlimpBrowserContext> browser_context, | 225 std::unique_ptr<BlimpBrowserContext> browser_context, |
217 net::NetLog* net_log, | 226 net::NetLog* net_log, |
218 BlimpEngineConfig* engine_config, | 227 BlimpEngineConfig* engine_config, |
219 SettingsManager* settings_manager) | 228 SettingsManager* settings_manager) |
220 : screen_(new BlimpScreen), | 229 : screen_(new BlimpScreen), |
221 browser_context_(std::move(browser_context)), | 230 browser_context_(std::move(browser_context)), |
222 engine_config_(engine_config), | 231 engine_config_(engine_config), |
223 settings_manager_(settings_manager), | 232 settings_manager_(settings_manager), |
224 settings_feature_(settings_manager_), | 233 settings_feature_(settings_manager_), |
225 render_widget_feature_(settings_manager_), | 234 render_widget_feature_(settings_manager_), |
226 net_components_( | 235 net_components_( |
227 new EngineNetworkComponents(net_log, | 236 new EngineNetworkComponents(net_log, |
228 QuitCurrentMessageLoopClosure())) { | 237 QuitCurrentMessageLoopClosure())) { |
229 DCHECK(engine_config_); | 238 DCHECK(engine_config_); |
230 DCHECK(settings_manager_); | 239 DCHECK(settings_manager_); |
231 | 240 |
232 screen_->UpdateDisplayScaleAndSize( | 241 screen_->UpdateDisplayScaleAndSize( |
233 kDefaultScaleFactor, | 242 kDefaultScaleFactor, |
234 gfx::Size(kDefaultDisplayWidth, kDefaultDisplayHeight)); | 243 gfx::Size(kDefaultDisplayWidth, kDefaultDisplayHeight)); |
235 render_widget_feature_.SetDelegate(kDummyTabId, this); | 244 render_widget_feature_.SetDelegate(kDummyTabId, this); |
236 | 245 |
237 std::unique_ptr<HeliumBlobSenderDelegate> helium_blob_delegate( | 246 std::unique_ptr<HeliumBlobSenderDelegate> helium_blob_delegate( |
238 new HeliumBlobSenderDelegate); | 247 new HeliumBlobSenderDelegate); |
239 blob_delegate_ = helium_blob_delegate.get(); | 248 blob_delegate_ = helium_blob_delegate.get(); |
240 blob_channel_sender_ = base::WrapUnique( | 249 blob_channel_sender_ = base::WrapUnique( |
241 new BlobChannelSenderImpl(base::WrapUnique(new InMemoryBlobCache), | 250 new BlobChannelSenderImpl(base::WrapUnique(new InMemoryBlobCache), |
242 std::move(helium_blob_delegate))); | 251 std::move(helium_blob_delegate))); |
243 blob_channel_service_ = | |
244 base::MakeUnique<BlobChannelService>(blob_channel_sender_.get()); | |
245 device::GeolocationProvider::SetGeolocationDelegate( | 252 device::GeolocationProvider::SetGeolocationDelegate( |
246 geolocation_feature_.CreateGeolocationDelegate()); | 253 geolocation_feature_.CreateGeolocationDelegate()); |
247 } | 254 } |
248 | 255 |
249 BlimpEngineSession::~BlimpEngineSession() { | 256 BlimpEngineSession::~BlimpEngineSession() { |
250 render_widget_feature_.RemoveDelegate(kDummyTabId); | 257 render_widget_feature_.RemoveDelegate(kDummyTabId); |
251 | 258 |
252 window_tree_host_->GetInputMethod()->RemoveObserver(this); | 259 window_tree_host_->GetInputMethod()->RemoveObserver(this); |
253 | 260 |
254 // Ensure that all tabs are torn down first, since teardown will | 261 // Ensure that all tabs are torn down first, since teardown will |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
288 window_tree_host_->SetBounds(gfx::Rect(screen_->GetPrimaryDisplay().size())); | 295 window_tree_host_->SetBounds(gfx::Rect(screen_->GetPrimaryDisplay().size())); |
289 | 296 |
290 RegisterFeatures(); | 297 RegisterFeatures(); |
291 | 298 |
292 // Initialize must only be posted after the RegisterFeature calls have | 299 // Initialize must only be posted after the RegisterFeature calls have |
293 // completed. | 300 // completed. |
294 content::BrowserThread::PostTask( | 301 content::BrowserThread::PostTask( |
295 content::BrowserThread::IO, FROM_HERE, | 302 content::BrowserThread::IO, FROM_HERE, |
296 base::Bind(&EngineNetworkComponents::Initialize, | 303 base::Bind(&EngineNetworkComponents::Initialize, |
297 base::Unretained(net_components_.get()), | 304 base::Unretained(net_components_.get()), |
305 base::ThreadTaskRunnerHandle::Get(), | |
306 blob_channel_sender_->GetWeakPtr(), | |
298 engine_config_->client_token())); | 307 engine_config_->client_token())); |
299 } | 308 } |
300 | 309 |
310 BlobChannelService* BlimpEngineSession::GetBlobChannelService() { | |
311 return net_components_->blob_channel_service(); | |
312 } | |
313 | |
301 void BlimpEngineSession::GetEnginePortForTesting( | 314 void BlimpEngineSession::GetEnginePortForTesting( |
302 const GetPortCallback& callback) { | 315 const GetPortCallback& callback) { |
303 content::BrowserThread::PostTaskAndReplyWithResult( | 316 content::BrowserThread::PostTaskAndReplyWithResult( |
304 content::BrowserThread::IO, FROM_HERE, | 317 content::BrowserThread::IO, FROM_HERE, |
305 base::Bind(&EngineNetworkComponents::GetPortForTesting, | 318 base::Bind(&EngineNetworkComponents::GetPortForTesting, |
306 base::Unretained(net_components_.get())), | 319 base::Unretained(net_components_.get())), |
307 callback); | 320 callback); |
308 } | 321 } |
309 | 322 |
310 void BlimpEngineSession::RegisterFeatures() { | 323 void BlimpEngineSession::RegisterFeatures() { |
311 thread_pipe_manager_.reset( | 324 thread_pipe_manager_.reset( |
312 new ThreadPipeManager(content::BrowserThread::GetTaskRunnerForThread( | 325 new ThreadPipeManager(content::BrowserThread::GetTaskRunnerForThread( |
313 content::BrowserThread::IO), | 326 content::BrowserThread::IO), |
314 net_components_->GetBrowserConnectionHandler())); | 327 net_components_->connection_handler())); |
315 | 328 |
316 // Register features' message senders and receivers. | 329 // Register features' message senders and receivers. |
317 tab_control_message_sender_ = | 330 tab_control_message_sender_ = |
318 thread_pipe_manager_->RegisterFeature(BlimpMessage::kTabControl, this); | 331 thread_pipe_manager_->RegisterFeature(BlimpMessage::kTabControl, this); |
319 navigation_message_sender_ = | 332 navigation_message_sender_ = |
320 thread_pipe_manager_->RegisterFeature(BlimpMessage::kNavigation, this); | 333 thread_pipe_manager_->RegisterFeature(BlimpMessage::kNavigation, this); |
321 render_widget_feature_.set_render_widget_message_sender( | 334 render_widget_feature_.set_render_widget_message_sender( |
322 thread_pipe_manager_->RegisterFeature(BlimpMessage::kRenderWidget, | 335 thread_pipe_manager_->RegisterFeature(BlimpMessage::kRenderWidget, |
323 &render_widget_feature_)); | 336 &render_widget_feature_)); |
324 render_widget_feature_.set_input_message_sender( | 337 render_widget_feature_.set_input_message_sender( |
(...skipping 247 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
572 parent->AddChild(content); | 585 parent->AddChild(content); |
573 content->Show(); | 586 content->Show(); |
574 | 587 |
575 tab_ = base::WrapUnique(new Tab(std::move(new_contents), target_tab_id, | 588 tab_ = base::WrapUnique(new Tab(std::move(new_contents), target_tab_id, |
576 &render_widget_feature_, | 589 &render_widget_feature_, |
577 navigation_message_sender_.get())); | 590 navigation_message_sender_.get())); |
578 } | 591 } |
579 | 592 |
580 } // namespace engine | 593 } // namespace engine |
581 } // namespace blimp | 594 } // namespace blimp |
OLD | NEW |