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 "content/child/service_worker/service_worker_network_provider.h" | 5 #include "content/child/service_worker/service_worker_network_provider.h" |
6 | 6 |
7 #include "base/atomic_sequence_num.h" | 7 #include "base/atomic_sequence_num.h" |
8 #include "content/child/child_thread_impl.h" | 8 #include "content/child/child_thread_impl.h" |
9 #include "content/child/service_worker/service_worker_provider_context.h" | 9 #include "content/child/service_worker/service_worker_provider_context.h" |
10 #include "content/common/navigation_params.h" | 10 #include "content/common/navigation_params.h" |
11 #include "content/common/service_worker/service_worker_messages.h" | 11 #include "content/common/service_worker/service_worker_messages.h" |
12 #include "content/common/service_worker/service_worker_utils.h" | 12 #include "content/common/service_worker/service_worker_utils.h" |
13 #include "content/public/common/browser_side_navigation_policy.h" | 13 #include "content/public/common/browser_side_navigation_policy.h" |
14 #include "third_party/WebKit/public/web/WebLocalFrame.h" | |
15 #include "third_party/WebKit/public/web/WebSandboxFlags.h" | |
16 | 14 |
17 namespace content { | 15 namespace content { |
18 | 16 |
19 namespace { | 17 namespace { |
20 | 18 |
21 const char kUserDataKey[] = "SWProviderKey"; | 19 const char kUserDataKey[] = "SWProviderKey"; |
22 | 20 |
23 // Must be unique in the child process. | 21 // Must be unique in the child process. |
24 int GetNextProviderId() { | 22 int GetNextProviderId() { |
25 static base::StaticAtomicSequenceNumber sequence; | 23 static base::StaticAtomicSequenceNumber sequence; |
(...skipping 12 matching lines...) Expand all Loading... |
38 base::SupportsUserData* datasource_userdata) { | 36 base::SupportsUserData* datasource_userdata) { |
39 return static_cast<ServiceWorkerNetworkProvider*>( | 37 return static_cast<ServiceWorkerNetworkProvider*>( |
40 datasource_userdata->GetUserData(&kUserDataKey)); | 38 datasource_userdata->GetUserData(&kUserDataKey)); |
41 } | 39 } |
42 | 40 |
43 // static | 41 // static |
44 std::unique_ptr<ServiceWorkerNetworkProvider> | 42 std::unique_ptr<ServiceWorkerNetworkProvider> |
45 ServiceWorkerNetworkProvider::CreateForNavigation( | 43 ServiceWorkerNetworkProvider::CreateForNavigation( |
46 int route_id, | 44 int route_id, |
47 const RequestNavigationParams& request_params, | 45 const RequestNavigationParams& request_params, |
48 blink::WebLocalFrame* frame, | 46 blink::WebSandboxFlags sandbox_flags, |
49 bool content_initiated) { | 47 bool content_initiated) { |
50 bool browser_side_navigation = IsBrowserSideNavigationEnabled(); | 48 bool browser_side_navigation = IsBrowserSideNavigationEnabled(); |
51 bool should_create_provider_for_window = false; | 49 bool should_create_provider_for_window = false; |
52 int service_worker_provider_id = kInvalidServiceWorkerProviderId; | 50 int service_worker_provider_id = kInvalidServiceWorkerProviderId; |
53 std::unique_ptr<ServiceWorkerNetworkProvider> network_provider; | 51 std::unique_ptr<ServiceWorkerNetworkProvider> network_provider; |
54 | 52 |
55 // Determine if a ServiceWorkerNetworkProvider should be created and properly | 53 // Determine if a ServiceWorkerNetworkProvider should be created and properly |
56 // initialized for the navigation. A default ServiceWorkerNetworkProvider | 54 // initialized for the navigation. A default ServiceWorkerNetworkProvider |
57 // will always be created since it is expected in a certain number of places, | 55 // will always be created since it is expected in a certain number of places, |
58 // however it will have an invalid id. | 56 // however it will have an invalid id. |
59 // PlzNavigate: |service_worker_provider_id| can be sent by the browser, if | 57 // PlzNavigate: |service_worker_provider_id| can be sent by the browser, if |
60 // it already created the SeviceWorkerProviderHost. | 58 // it already created the SeviceWorkerProviderHost. |
61 if (browser_side_navigation && !content_initiated) { | 59 if (browser_side_navigation && !content_initiated) { |
62 should_create_provider_for_window = | 60 should_create_provider_for_window = |
63 request_params.should_create_service_worker; | 61 request_params.should_create_service_worker; |
64 service_worker_provider_id = request_params.service_worker_provider_id; | 62 service_worker_provider_id = request_params.service_worker_provider_id; |
65 DCHECK(ServiceWorkerUtils::IsBrowserAssignedProviderId( | 63 DCHECK(ServiceWorkerUtils::IsBrowserAssignedProviderId( |
66 service_worker_provider_id) || | 64 service_worker_provider_id) || |
67 service_worker_provider_id == kInvalidServiceWorkerProviderId); | 65 service_worker_provider_id == kInvalidServiceWorkerProviderId); |
68 } else { | 66 } else { |
69 should_create_provider_for_window = | 67 should_create_provider_for_window = |
70 ((frame->effectiveSandboxFlags() & blink::WebSandboxFlags::Origin) != | 68 (sandbox_flags & blink::WebSandboxFlags::Origin) != |
71 blink::WebSandboxFlags::Origin); | 69 blink::WebSandboxFlags::Origin; |
72 } | 70 } |
73 | 71 |
74 // Now create the ServiceWorkerNetworkProvider (with invalid id if needed). | 72 // Now create the ServiceWorkerNetworkProvider (with invalid id if needed). |
75 if (should_create_provider_for_window) { | 73 if (should_create_provider_for_window) { |
76 // Ideally Document::isSecureContext would be called here, but the document | |
77 // is not created yet, and due to redirects the URL may change. So pass | |
78 // is_parent_frame_secure to the browser process, so it can determine the | |
79 // context security when deciding whether to allow a service worker to | |
80 // control the document. | |
81 bool is_parent_frame_secure = | |
82 !frame->parent() || frame->parent()->canHaveSecureChild(); | |
83 | |
84 if (service_worker_provider_id == kInvalidServiceWorkerProviderId) { | 74 if (service_worker_provider_id == kInvalidServiceWorkerProviderId) { |
85 network_provider = std::unique_ptr<ServiceWorkerNetworkProvider>( | 75 network_provider = std::unique_ptr<ServiceWorkerNetworkProvider>( |
86 new ServiceWorkerNetworkProvider(route_id, | 76 new ServiceWorkerNetworkProvider(route_id, |
87 SERVICE_WORKER_PROVIDER_FOR_WINDOW, | 77 SERVICE_WORKER_PROVIDER_FOR_WINDOW)); |
88 is_parent_frame_secure)); | |
89 } else { | 78 } else { |
90 CHECK(browser_side_navigation); | 79 CHECK(browser_side_navigation); |
91 DCHECK(ServiceWorkerUtils::IsBrowserAssignedProviderId( | 80 DCHECK(ServiceWorkerUtils::IsBrowserAssignedProviderId( |
92 service_worker_provider_id)); | 81 service_worker_provider_id)); |
93 network_provider = std::unique_ptr<ServiceWorkerNetworkProvider>( | 82 network_provider = std::unique_ptr<ServiceWorkerNetworkProvider>( |
94 new ServiceWorkerNetworkProvider( | 83 new ServiceWorkerNetworkProvider(route_id, |
95 route_id, SERVICE_WORKER_PROVIDER_FOR_WINDOW, | 84 SERVICE_WORKER_PROVIDER_FOR_WINDOW, |
96 service_worker_provider_id, is_parent_frame_secure)); | 85 service_worker_provider_id)); |
97 } | 86 } |
98 } else { | 87 } else { |
99 network_provider = std::unique_ptr<ServiceWorkerNetworkProvider>( | 88 network_provider = std::unique_ptr<ServiceWorkerNetworkProvider>( |
100 new ServiceWorkerNetworkProvider()); | 89 new ServiceWorkerNetworkProvider()); |
101 } | 90 } |
102 return network_provider; | 91 return network_provider; |
103 } | 92 } |
104 | 93 |
105 ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider( | 94 ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider( |
106 int route_id, | 95 int route_id, |
107 ServiceWorkerProviderType provider_type, | 96 ServiceWorkerProviderType provider_type, |
108 int browser_provider_id, | 97 int browser_provider_id) |
109 bool is_parent_frame_secure) | |
110 : provider_id_(browser_provider_id) { | 98 : provider_id_(browser_provider_id) { |
111 if (provider_id_ == kInvalidServiceWorkerProviderId) | 99 if (provider_id_ == kInvalidServiceWorkerProviderId) |
112 return; | 100 return; |
113 if (!ChildThreadImpl::current()) | 101 if (!ChildThreadImpl::current()) |
114 return; // May be null in some tests. | 102 return; // May be null in some tests. |
115 context_ = new ServiceWorkerProviderContext( | 103 context_ = new ServiceWorkerProviderContext( |
116 provider_id_, provider_type, | 104 provider_id_, provider_type, |
117 ChildThreadImpl::current()->thread_safe_sender()); | 105 ChildThreadImpl::current()->thread_safe_sender()); |
118 ChildThreadImpl::current()->Send(new ServiceWorkerHostMsg_ProviderCreated( | 106 ChildThreadImpl::current()->Send(new ServiceWorkerHostMsg_ProviderCreated( |
119 provider_id_, route_id, provider_type, is_parent_frame_secure)); | 107 provider_id_, route_id, provider_type)); |
120 } | 108 } |
121 | 109 |
122 ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider( | 110 ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider( |
123 int route_id, | 111 int route_id, |
124 ServiceWorkerProviderType provider_type, | 112 ServiceWorkerProviderType provider_type) |
125 bool is_parent_frame_secure) | |
126 : ServiceWorkerNetworkProvider(route_id, | 113 : ServiceWorkerNetworkProvider(route_id, |
127 provider_type, | 114 provider_type, |
128 GetNextProviderId(), | 115 GetNextProviderId()) {} |
129 is_parent_frame_secure) {} | |
130 | 116 |
131 ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider() | 117 ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider() |
132 : provider_id_(kInvalidServiceWorkerProviderId) {} | 118 : provider_id_(kInvalidServiceWorkerProviderId) {} |
133 | 119 |
134 ServiceWorkerNetworkProvider::~ServiceWorkerNetworkProvider() { | 120 ServiceWorkerNetworkProvider::~ServiceWorkerNetworkProvider() { |
135 if (provider_id_ == kInvalidServiceWorkerProviderId) | 121 if (provider_id_ == kInvalidServiceWorkerProviderId) |
136 return; | 122 return; |
137 if (!ChildThreadImpl::current()) | 123 if (!ChildThreadImpl::current()) |
138 return; // May be null in some tests. | 124 return; // May be null in some tests. |
139 ChildThreadImpl::current()->Send( | 125 ChildThreadImpl::current()->Send( |
140 new ServiceWorkerHostMsg_ProviderDestroyed(provider_id_)); | 126 new ServiceWorkerHostMsg_ProviderDestroyed(provider_id_)); |
141 } | 127 } |
142 | 128 |
143 void ServiceWorkerNetworkProvider::SetServiceWorkerVersionId( | 129 void ServiceWorkerNetworkProvider::SetServiceWorkerVersionId( |
144 int64_t version_id) { | 130 int64_t version_id) { |
145 DCHECK_NE(kInvalidServiceWorkerProviderId, provider_id_); | 131 DCHECK_NE(kInvalidServiceWorkerProviderId, provider_id_); |
146 if (!ChildThreadImpl::current()) | 132 if (!ChildThreadImpl::current()) |
147 return; // May be null in some tests. | 133 return; // May be null in some tests. |
148 ChildThreadImpl::current()->Send( | 134 ChildThreadImpl::current()->Send( |
149 new ServiceWorkerHostMsg_SetVersionId(provider_id_, version_id)); | 135 new ServiceWorkerHostMsg_SetVersionId(provider_id_, version_id)); |
150 } | 136 } |
151 | 137 |
152 bool ServiceWorkerNetworkProvider::IsControlledByServiceWorker() const { | 138 bool ServiceWorkerNetworkProvider::IsControlledByServiceWorker() const { |
153 return context() && context()->controller(); | 139 return context() && context()->controller(); |
154 } | 140 } |
155 | 141 |
156 } // namespace content | 142 } // namespace content |
OLD | NEW |