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 "headless/lib/browser/headless_browser_context.h" | 5 #include "headless/lib/browser/headless_browser_context_impl.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
| 9 #include "base/memory/ptr_util.h" |
9 #include "base/path_service.h" | 10 #include "base/path_service.h" |
10 #include "content/public/browser/browser_thread.h" | 11 #include "content/public/browser/browser_thread.h" |
11 #include "content/public/browser/resource_context.h" | 12 #include "content/public/browser/resource_context.h" |
12 #include "content/public/browser/storage_partition.h" | 13 #include "content/public/browser/storage_partition.h" |
| 14 #include "headless/lib/browser/headless_browser_impl.h" |
13 #include "headless/lib/browser/headless_url_request_context_getter.h" | 15 #include "headless/lib/browser/headless_url_request_context_getter.h" |
14 #include "net/url_request/url_request_context.h" | 16 #include "net/url_request/url_request_context.h" |
15 | 17 |
16 namespace headless { | 18 namespace headless { |
17 | 19 |
18 // Contains net::URLRequestContextGetter required for resource loading. | 20 // Contains net::URLRequestContextGetter required for resource loading. |
19 // Must be destructed on the IO thread as per content::ResourceContext | 21 // Must be destructed on the IO thread as per content::ResourceContext |
20 // requirements. | 22 // requirements. |
21 class HeadlessResourceContext : public content::ResourceContext { | 23 class HeadlessResourceContext : public content::ResourceContext { |
22 public: | 24 public: |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
57 net::HostResolver* HeadlessResourceContext::GetHostResolver() { | 59 net::HostResolver* HeadlessResourceContext::GetHostResolver() { |
58 CHECK(url_request_context_getter_); | 60 CHECK(url_request_context_getter_); |
59 return url_request_context_getter_->GetURLRequestContext()->host_resolver(); | 61 return url_request_context_getter_->GetURLRequestContext()->host_resolver(); |
60 } | 62 } |
61 | 63 |
62 net::URLRequestContext* HeadlessResourceContext::GetRequestContext() { | 64 net::URLRequestContext* HeadlessResourceContext::GetRequestContext() { |
63 CHECK(url_request_context_getter_); | 65 CHECK(url_request_context_getter_); |
64 return url_request_context_getter_->GetURLRequestContext(); | 66 return url_request_context_getter_->GetURLRequestContext(); |
65 } | 67 } |
66 | 68 |
67 HeadlessBrowserContext::HeadlessBrowserContext( | 69 HeadlessBrowserContextImpl::HeadlessBrowserContextImpl( |
68 HeadlessBrowser::Options* options) | 70 HeadlessBrowser::Options* options) |
69 : resource_context_(new HeadlessResourceContext), options_(options) { | 71 : resource_context_(new HeadlessResourceContext), options_(options) { |
70 InitWhileIOAllowed(); | 72 InitWhileIOAllowed(); |
71 } | 73 } |
72 | 74 |
73 HeadlessBrowserContext::~HeadlessBrowserContext() { | 75 HeadlessBrowserContextImpl::~HeadlessBrowserContextImpl() { |
74 if (resource_context_) { | 76 if (resource_context_) { |
75 content::BrowserThread::DeleteSoon(content::BrowserThread::IO, FROM_HERE, | 77 content::BrowserThread::DeleteSoon(content::BrowserThread::IO, FROM_HERE, |
76 resource_context_.release()); | 78 resource_context_.release()); |
77 } | 79 } |
78 } | 80 } |
79 | 81 |
80 void HeadlessBrowserContext::InitWhileIOAllowed() { | 82 void HeadlessBrowserContextImpl::InitWhileIOAllowed() { |
81 // TODO(skyostil): Allow the embedder to override this. | 83 // TODO(skyostil): Allow the embedder to override this. |
82 PathService::Get(base::DIR_EXE, &path_); | 84 PathService::Get(base::DIR_EXE, &path_); |
83 BrowserContext::Initialize(this, path_); | 85 BrowserContext::Initialize(this, path_); |
84 } | 86 } |
85 | 87 |
86 std::unique_ptr<content::ZoomLevelDelegate> | 88 std::unique_ptr<content::ZoomLevelDelegate> |
87 HeadlessBrowserContext::CreateZoomLevelDelegate( | 89 HeadlessBrowserContextImpl::CreateZoomLevelDelegate( |
88 const base::FilePath& partition_path) { | 90 const base::FilePath& partition_path) { |
89 return std::unique_ptr<content::ZoomLevelDelegate>(); | 91 return std::unique_ptr<content::ZoomLevelDelegate>(); |
90 } | 92 } |
91 | 93 |
92 base::FilePath HeadlessBrowserContext::GetPath() const { | 94 base::FilePath HeadlessBrowserContextImpl::GetPath() const { |
93 return path_; | 95 return path_; |
94 } | 96 } |
95 | 97 |
96 bool HeadlessBrowserContext::IsOffTheRecord() const { | 98 bool HeadlessBrowserContextImpl::IsOffTheRecord() const { |
97 return false; | 99 return false; |
98 } | 100 } |
99 | 101 |
100 content::ResourceContext* HeadlessBrowserContext::GetResourceContext() { | 102 content::ResourceContext* HeadlessBrowserContextImpl::GetResourceContext() { |
101 return resource_context_.get(); | 103 return resource_context_.get(); |
102 } | 104 } |
103 | 105 |
104 content::DownloadManagerDelegate* | 106 content::DownloadManagerDelegate* |
105 HeadlessBrowserContext::GetDownloadManagerDelegate() { | 107 HeadlessBrowserContextImpl::GetDownloadManagerDelegate() { |
106 return nullptr; | 108 return nullptr; |
107 } | 109 } |
108 | 110 |
109 content::BrowserPluginGuestManager* HeadlessBrowserContext::GetGuestManager() { | 111 content::BrowserPluginGuestManager* |
| 112 HeadlessBrowserContextImpl::GetGuestManager() { |
110 // TODO(altimin): Should be non-null? (is null in content/shell). | 113 // TODO(altimin): Should be non-null? (is null in content/shell). |
111 return nullptr; | 114 return nullptr; |
112 } | 115 } |
113 | 116 |
114 storage::SpecialStoragePolicy* | 117 storage::SpecialStoragePolicy* |
115 HeadlessBrowserContext::GetSpecialStoragePolicy() { | 118 HeadlessBrowserContextImpl::GetSpecialStoragePolicy() { |
116 return nullptr; | 119 return nullptr; |
117 } | 120 } |
118 | 121 |
119 content::PushMessagingService* | 122 content::PushMessagingService* |
120 HeadlessBrowserContext::GetPushMessagingService() { | 123 HeadlessBrowserContextImpl::GetPushMessagingService() { |
121 return nullptr; | 124 return nullptr; |
122 } | 125 } |
123 | 126 |
124 content::SSLHostStateDelegate* | 127 content::SSLHostStateDelegate* |
125 HeadlessBrowserContext::GetSSLHostStateDelegate() { | 128 HeadlessBrowserContextImpl::GetSSLHostStateDelegate() { |
126 return nullptr; | 129 return nullptr; |
127 } | 130 } |
128 | 131 |
129 content::PermissionManager* HeadlessBrowserContext::GetPermissionManager() { | 132 content::PermissionManager* HeadlessBrowserContextImpl::GetPermissionManager() { |
130 return nullptr; | 133 return nullptr; |
131 } | 134 } |
132 | 135 |
133 content::BackgroundSyncController* | 136 content::BackgroundSyncController* |
134 HeadlessBrowserContext::GetBackgroundSyncController() { | 137 HeadlessBrowserContextImpl::GetBackgroundSyncController() { |
135 return nullptr; | 138 return nullptr; |
136 } | 139 } |
137 | 140 |
138 net::URLRequestContextGetter* HeadlessBrowserContext::CreateRequestContext( | 141 net::URLRequestContextGetter* HeadlessBrowserContextImpl::CreateRequestContext( |
139 content::ProtocolHandlerMap* protocol_handlers, | 142 content::ProtocolHandlerMap* protocol_handlers, |
140 content::URLRequestInterceptorScopedVector request_interceptors) { | 143 content::URLRequestInterceptorScopedVector request_interceptors) { |
141 scoped_refptr<HeadlessURLRequestContextGetter> url_request_context_getter( | 144 scoped_refptr<HeadlessURLRequestContextGetter> url_request_context_getter( |
142 new HeadlessURLRequestContextGetter( | 145 new HeadlessURLRequestContextGetter( |
143 content::BrowserThread::GetMessageLoopProxyForThread( | 146 content::BrowserThread::GetMessageLoopProxyForThread( |
144 content::BrowserThread::IO), | 147 content::BrowserThread::IO), |
145 content::BrowserThread::GetMessageLoopProxyForThread( | 148 content::BrowserThread::GetMessageLoopProxyForThread( |
146 content::BrowserThread::FILE), | 149 content::BrowserThread::FILE), |
147 protocol_handlers, std::move(request_interceptors), options())); | 150 protocol_handlers, std::move(request_interceptors), options())); |
148 resource_context_->set_url_request_context_getter(url_request_context_getter); | 151 resource_context_->set_url_request_context_getter(url_request_context_getter); |
149 return url_request_context_getter.get(); | 152 return url_request_context_getter.get(); |
150 } | 153 } |
151 | 154 |
152 net::URLRequestContextGetter* | 155 net::URLRequestContextGetter* |
153 HeadlessBrowserContext::CreateRequestContextForStoragePartition( | 156 HeadlessBrowserContextImpl::CreateRequestContextForStoragePartition( |
154 const base::FilePath& partition_path, | 157 const base::FilePath& partition_path, |
155 bool in_memory, | 158 bool in_memory, |
156 content::ProtocolHandlerMap* protocol_handlers, | 159 content::ProtocolHandlerMap* protocol_handlers, |
157 content::URLRequestInterceptorScopedVector request_interceptors) { | 160 content::URLRequestInterceptorScopedVector request_interceptors) { |
158 return nullptr; | 161 return nullptr; |
159 } | 162 } |
160 | 163 |
161 net::URLRequestContextGetter* | 164 net::URLRequestContextGetter* |
162 HeadlessBrowserContext::CreateMediaRequestContext() { | 165 HeadlessBrowserContextImpl::CreateMediaRequestContext() { |
163 return resource_context_->url_request_context_getter(); | 166 return resource_context_->url_request_context_getter(); |
164 } | 167 } |
165 | 168 |
166 net::URLRequestContextGetter* | 169 net::URLRequestContextGetter* |
167 HeadlessBrowserContext::CreateMediaRequestContextForStoragePartition( | 170 HeadlessBrowserContextImpl::CreateMediaRequestContextForStoragePartition( |
168 const base::FilePath& partition_path, | 171 const base::FilePath& partition_path, |
169 bool in_memory) { | 172 bool in_memory) { |
170 return nullptr; | 173 return nullptr; |
171 } | 174 } |
172 | 175 |
173 void HeadlessBrowserContext::SetOptionsForTesting( | 176 void HeadlessBrowserContextImpl::SetOptionsForTesting( |
174 HeadlessBrowser::Options* options) { | 177 HeadlessBrowser::Options* options) { |
175 options_ = options; | 178 options_ = options; |
176 } | 179 } |
177 | 180 |
| 181 HeadlessBrowserContext::Builder::Builder(HeadlessBrowserImpl* browser) |
| 182 : browser_(browser) {} |
| 183 |
| 184 HeadlessBrowserContext::Builder::~Builder() = default; |
| 185 |
| 186 HeadlessBrowserContext::Builder::Builder(Builder&&) = default; |
| 187 |
| 188 std::unique_ptr<HeadlessBrowserContext> |
| 189 HeadlessBrowserContext::Builder::Build() { |
| 190 return base::WrapUnique(new HeadlessBrowserContextImpl(browser_->options())); |
| 191 } |
| 192 |
178 } // namespace headless | 193 } // namespace headless |
OLD | NEW |