OLD | NEW |
1 // Copyright (c) 2016 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2016 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 "content/renderer/service_worker/embedded_worker_instance_client_impl.h
" | 5 #include "content/renderer/service_worker/embedded_worker_instance_client_impl.h
" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "base/memory/ptr_util.h" | 9 #include "base/memory/ptr_util.h" |
| 10 #include "base/metrics/histogram_macros.h" |
10 #include "base/strings/utf_string_conversions.h" | 11 #include "base/strings/utf_string_conversions.h" |
11 #include "content/child/scoped_child_process_reference.h" | 12 #include "content/child/scoped_child_process_reference.h" |
12 #include "content/common/service_worker/embedded_worker_messages.h" | 13 #include "content/common/service_worker/embedded_worker_messages.h" |
13 #include "content/public/common/content_client.h" | 14 #include "content/public/common/content_client.h" |
14 #include "content/renderer/service_worker/embedded_worker_devtools_agent.h" | 15 #include "content/renderer/service_worker/embedded_worker_devtools_agent.h" |
15 #include "content/renderer/service_worker/service_worker_context_client.h" | 16 #include "content/renderer/service_worker/service_worker_context_client.h" |
16 #include "third_party/WebKit/public/web/WebEmbeddedWorker.h" | 17 #include "third_party/WebKit/public/web/WebEmbeddedWorker.h" |
17 #include "third_party/WebKit/public/web/WebEmbeddedWorkerStartData.h" | 18 #include "third_party/WebKit/public/web/WebEmbeddedWorkerStartData.h" |
18 | 19 |
19 namespace content { | 20 namespace content { |
20 | 21 |
| 22 EmbeddedWorkerInstanceClientImpl::WorkerWrapper::WorkerWrapper( |
| 23 blink::WebEmbeddedWorker* worker, |
| 24 int devtools_agent_route_id) |
| 25 : worker_(worker), |
| 26 devtools_agent_(base::MakeUnique<EmbeddedWorkerDevToolsAgent>( |
| 27 worker, |
| 28 devtools_agent_route_id)) {} |
| 29 |
| 30 EmbeddedWorkerInstanceClientImpl::WorkerWrapper::~WorkerWrapper() = default; |
| 31 |
21 // static | 32 // static |
22 void EmbeddedWorkerInstanceClientImpl::Create( | 33 void EmbeddedWorkerInstanceClientImpl::Create( |
23 EmbeddedWorkerDispatcher* dispatcher, | |
24 mojo::InterfaceRequest<mojom::EmbeddedWorkerInstanceClient> request) { | 34 mojo::InterfaceRequest<mojom::EmbeddedWorkerInstanceClient> request) { |
25 // This won't be leaked because the lifetime will be managed internally. | 35 // This won't be leaked because the lifetime will be managed internally. |
26 new EmbeddedWorkerInstanceClientImpl(dispatcher, std::move(request)); | 36 new EmbeddedWorkerInstanceClientImpl(std::move(request)); |
27 } | 37 } |
28 | 38 |
29 void EmbeddedWorkerInstanceClientImpl::StopWorkerCompleted() { | 39 void EmbeddedWorkerInstanceClientImpl::WorkerContextDestroyed() { |
30 DCHECK(embedded_worker_id_); | 40 DCHECK(wrapper_); |
31 DCHECK(stop_callback_); | |
32 TRACE_EVENT0("ServiceWorker", | 41 TRACE_EVENT0("ServiceWorker", |
33 "EmbeddedWorkerInstanceClientImpl::StopWorkerCompleted"); | 42 "EmbeddedWorkerInstanceClientImpl::WorkerContextDestroyed"); |
34 // TODO(falken): The signals to the browser should be in the order: | 43 |
35 // (1) WorkerStopped (via stop_callback_) | 44 if (stop_worker_time_) { |
36 // (2) ProviderDestroyed (via UnregisterWorker destroying | 45 UMA_HISTOGRAM_MEDIUM_TIMES( |
37 // WebEmbeddedWorkerImpl) | 46 "ServiceWorker.TerminateThread.Time", |
38 // But this ordering is currently not guaranteed since the Mojo pipes are | 47 base::TimeTicks::Now() - stop_worker_time_.value()); |
39 // different. https://crbug.com/676526 | 48 stop_worker_time_.reset(); |
40 stop_callback_.Run(); | 49 } |
41 stop_callback_.Reset(); | 50 wrapper_.reset(); |
42 dispatcher_->UnregisterWorker(embedded_worker_id_.value()); | |
43 embedded_worker_id_.reset(); | |
44 wrapper_ = nullptr; | |
45 } | 51 } |
46 | 52 |
47 void EmbeddedWorkerInstanceClientImpl::StartWorker( | 53 void EmbeddedWorkerInstanceClientImpl::StartWorker( |
48 const EmbeddedWorkerStartParams& params, | 54 const EmbeddedWorkerStartParams& params, |
49 mojom::ServiceWorkerEventDispatcherRequest dispatcher_request) { | 55 mojom::ServiceWorkerEventDispatcherRequest dispatcher_request, |
| 56 mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo instance_host) { |
50 DCHECK(ChildThreadImpl::current()); | 57 DCHECK(ChildThreadImpl::current()); |
51 DCHECK(!wrapper_); | 58 DCHECK(!wrapper_); |
52 DCHECK(!embedded_worker_id_); | 59 DCHECK(!stop_worker_time_.has_value()); |
53 TRACE_EVENT0("ServiceWorker", | 60 TRACE_EVENT0("ServiceWorker", |
54 "EmbeddedWorkerInstanceClientImpl::StartWorker"); | 61 "EmbeddedWorkerInstanceClientImpl::StartWorker"); |
55 embedded_worker_id_ = params.embedded_worker_id; | |
56 | 62 |
57 std::unique_ptr<EmbeddedWorkerDispatcher::WorkerWrapper> wrapper = | 63 wrapper_ = StartWorkerContext( |
58 dispatcher_->StartWorkerContext( | 64 params, |
59 params, | 65 base::MakeUnique<ServiceWorkerContextClient>( |
60 base::MakeUnique<ServiceWorkerContextClient>( | 66 params.embedded_worker_id, params.service_worker_version_id, |
61 params.embedded_worker_id, params.service_worker_version_id, | 67 params.scope, params.script_url, std::move(dispatcher_request), |
62 params.scope, params.script_url, | 68 std::move(instance_host), std::move(temporal_self_))); |
63 std::move(dispatcher_request), std::move(temporal_self_))); | |
64 wrapper_ = wrapper.get(); | |
65 dispatcher_->RegisterWorker(params.embedded_worker_id, std::move(wrapper)); | |
66 } | 69 } |
67 | 70 |
68 void EmbeddedWorkerInstanceClientImpl::StopWorker( | 71 void EmbeddedWorkerInstanceClientImpl::StopWorker() { |
69 const StopWorkerCallback& callback) { | |
70 // StopWorker must be called after StartWorker is called. | 72 // StopWorker must be called after StartWorker is called. |
71 DCHECK(ChildThreadImpl::current()); | 73 DCHECK(ChildThreadImpl::current()); |
72 DCHECK(wrapper_); | 74 DCHECK(wrapper_); |
73 DCHECK(embedded_worker_id_); | 75 DCHECK(!stop_worker_time_.has_value()); |
74 DCHECK(!stop_callback_); | |
75 | 76 |
76 TRACE_EVENT0("ServiceWorker", "EmbeddedWorkerInstanceClientImpl::StopWorker"); | 77 TRACE_EVENT0("ServiceWorker", "EmbeddedWorkerInstanceClientImpl::StopWorker"); |
77 stop_callback_ = callback; | 78 stop_worker_time_ = base::TimeTicks::Now(); |
78 dispatcher_->RecordStopWorkerTimer(embedded_worker_id_.value()); | |
79 wrapper_->worker()->TerminateWorkerContext(); | 79 wrapper_->worker()->TerminateWorkerContext(); |
80 } | 80 } |
81 | 81 |
82 void EmbeddedWorkerInstanceClientImpl::ResumeAfterDownload() { | 82 void EmbeddedWorkerInstanceClientImpl::ResumeAfterDownload() { |
83 DCHECK(wrapper_); | 83 DCHECK(wrapper_); |
84 DCHECK(wrapper_->worker()); | 84 DCHECK(wrapper_->worker()); |
85 wrapper_->worker()->ResumeAfterDownload(); | 85 wrapper_->worker()->ResumeAfterDownload(); |
86 } | 86 } |
87 | 87 |
88 void EmbeddedWorkerInstanceClientImpl::AddMessageToConsole( | 88 void EmbeddedWorkerInstanceClientImpl::AddMessageToConsole( |
89 blink::WebConsoleMessage::Level level, | 89 blink::WebConsoleMessage::Level level, |
90 const std::string& message) { | 90 const std::string& message) { |
91 DCHECK(wrapper_); | 91 DCHECK(wrapper_); |
92 DCHECK(wrapper_->worker()); | 92 DCHECK(wrapper_->worker()); |
93 wrapper_->worker()->AddMessageToConsole( | 93 wrapper_->worker()->AddMessageToConsole( |
94 blink::WebConsoleMessage(level, blink::WebString::FromUTF8(message))); | 94 blink::WebConsoleMessage(level, blink::WebString::FromUTF8(message))); |
95 } | 95 } |
96 | 96 |
97 EmbeddedWorkerInstanceClientImpl::EmbeddedWorkerInstanceClientImpl( | 97 EmbeddedWorkerInstanceClientImpl::EmbeddedWorkerInstanceClientImpl( |
98 EmbeddedWorkerDispatcher* dispatcher, | |
99 mojo::InterfaceRequest<mojom::EmbeddedWorkerInstanceClient> request) | 98 mojo::InterfaceRequest<mojom::EmbeddedWorkerInstanceClient> request) |
100 : dispatcher_(dispatcher), | 99 : binding_(this, std::move(request)), temporal_self_(this) { |
101 binding_(this, std::move(request)), | |
102 temporal_self_(std::unique_ptr<EmbeddedWorkerInstanceClientImpl>(this)), | |
103 wrapper_(nullptr) { | |
104 binding_.set_connection_error_handler(base::Bind( | 100 binding_.set_connection_error_handler(base::Bind( |
105 &EmbeddedWorkerInstanceClientImpl::OnError, base::Unretained(this))); | 101 &EmbeddedWorkerInstanceClientImpl::OnError, base::Unretained(this))); |
106 } | 102 } |
107 | 103 |
108 EmbeddedWorkerInstanceClientImpl::~EmbeddedWorkerInstanceClientImpl() {} | 104 EmbeddedWorkerInstanceClientImpl::~EmbeddedWorkerInstanceClientImpl() {} |
109 | 105 |
110 void EmbeddedWorkerInstanceClientImpl::OnError() { | 106 void EmbeddedWorkerInstanceClientImpl::OnError() { |
111 // Removes myself if it's owned by myself. | 107 // Removes myself if it's owned by myself. |
112 temporal_self_.reset(); | 108 temporal_self_.reset(); |
113 } | 109 } |
114 | 110 |
| 111 std::unique_ptr<EmbeddedWorkerInstanceClientImpl::WorkerWrapper> |
| 112 EmbeddedWorkerInstanceClientImpl::StartWorkerContext( |
| 113 const EmbeddedWorkerStartParams& params, |
| 114 std::unique_ptr<ServiceWorkerContextClient> context_client) { |
| 115 auto wrapper = base::MakeUnique<WorkerWrapper>( |
| 116 blink::WebEmbeddedWorker::Create(context_client.release(), nullptr), |
| 117 params.worker_devtools_agent_route_id); |
| 118 |
| 119 blink::WebEmbeddedWorkerStartData start_data; |
| 120 start_data.script_url = params.script_url; |
| 121 start_data.user_agent = |
| 122 blink::WebString::FromUTF8(GetContentClient()->GetUserAgent()); |
| 123 start_data.wait_for_debugger_mode = |
| 124 params.wait_for_debugger |
| 125 ? blink::WebEmbeddedWorkerStartData::kWaitForDebugger |
| 126 : blink::WebEmbeddedWorkerStartData::kDontWaitForDebugger; |
| 127 start_data.v8_cache_options = static_cast<blink::WebSettings::V8CacheOptions>( |
| 128 params.settings.v8_cache_options); |
| 129 start_data.data_saver_enabled = params.settings.data_saver_enabled; |
| 130 start_data.pause_after_download_mode = |
| 131 params.pause_after_download |
| 132 ? blink::WebEmbeddedWorkerStartData::kPauseAfterDownload |
| 133 : blink::WebEmbeddedWorkerStartData::kDontPauseAfterDownload; |
| 134 |
| 135 wrapper->worker()->StartWorkerContext(start_data); |
| 136 return wrapper; |
| 137 } |
| 138 |
115 } // namespace content | 139 } // namespace content |
OLD | NEW |