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_web_contents_impl.h" | 5 #include "headless/lib/browser/headless_web_contents_impl.h" |
6 | 6 |
| 7 #include <string> |
| 8 #include <utility> |
| 9 |
7 #include "base/bind.h" | 10 #include "base/bind.h" |
8 #include "base/json/json_writer.h" | 11 #include "base/json/json_writer.h" |
9 #include "base/memory/ptr_util.h" | 12 #include "base/memory/ptr_util.h" |
10 #include "base/memory/weak_ptr.h" | 13 #include "base/memory/weak_ptr.h" |
11 #include "base/strings/utf_string_conversions.h" | 14 #include "base/strings/utf_string_conversions.h" |
12 #include "base/trace_event/trace_event.h" | 15 #include "base/trace_event/trace_event.h" |
13 #include "content/public/browser/devtools_agent_host.h" | 16 #include "content/public/browser/devtools_agent_host.h" |
14 #include "content/public/browser/navigation_handle.h" | 17 #include "content/public/browser/navigation_handle.h" |
15 #include "content/public/browser/render_frame_host.h" | 18 #include "content/public/browser/render_frame_host.h" |
16 #include "content/public/browser/render_process_host.h" | 19 #include "content/public/browser/render_process_host.h" |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
51 } | 54 } |
52 | 55 |
53 private: | 56 private: |
54 HeadlessWebContents::Observer* observer_; // Not owned. | 57 HeadlessWebContents::Observer* observer_; // Not owned. |
55 | 58 |
56 DISALLOW_COPY_AND_ASSIGN(WebContentsObserverAdapter); | 59 DISALLOW_COPY_AND_ASSIGN(WebContentsObserverAdapter); |
57 }; | 60 }; |
58 | 61 |
59 class HeadlessWebContentsImpl::Delegate : public content::WebContentsDelegate { | 62 class HeadlessWebContentsImpl::Delegate : public content::WebContentsDelegate { |
60 public: | 63 public: |
61 explicit Delegate(HeadlessBrowserImpl* browser) : browser_(browser) {} | 64 explicit Delegate(HeadlessBrowserContextImpl* browser_context) |
| 65 : browser_context_(browser_context) {} |
62 | 66 |
63 void WebContentsCreated(content::WebContents* source_contents, | 67 void WebContentsCreated(content::WebContents* source_contents, |
64 int opener_render_frame_id, | 68 int opener_render_frame_id, |
65 const std::string& frame_name, | 69 const std::string& frame_name, |
66 const GURL& target_url, | 70 const GURL& target_url, |
67 content::WebContents* new_contents) override { | 71 content::WebContents* new_contents) override { |
68 browser_->RegisterWebContents( | 72 std::unique_ptr<HeadlessWebContentsImpl> web_contents = |
69 HeadlessWebContentsImpl::CreateFromWebContents(new_contents, browser_)); | 73 HeadlessWebContentsImpl::CreateFromWebContents(new_contents, |
| 74 browser_context_); |
| 75 |
| 76 DCHECK(new_contents->GetBrowserContext() == browser_context_); |
| 77 |
| 78 browser_context_->RegisterWebContents(web_contents.get()); |
| 79 browser_context_->browser()->RegisterWebContents(std::move(web_contents)); |
70 } | 80 } |
71 | 81 |
72 private: | 82 private: |
73 HeadlessBrowserImpl* browser_; // Not owned. | 83 HeadlessBrowserContextImpl* browser_context_; // Not owned. |
74 DISALLOW_COPY_AND_ASSIGN(Delegate); | 84 DISALLOW_COPY_AND_ASSIGN(Delegate); |
75 }; | 85 }; |
76 | 86 |
77 // static | 87 // static |
78 std::unique_ptr<HeadlessWebContentsImpl> HeadlessWebContentsImpl::Create( | 88 std::unique_ptr<HeadlessWebContentsImpl> HeadlessWebContentsImpl::Create( |
79 HeadlessWebContents::Builder* builder, | 89 HeadlessWebContents::Builder* builder, |
80 aura::Window* parent_window, | 90 aura::Window* parent_window) { |
81 HeadlessBrowserImpl* browser) { | 91 content::WebContents::CreateParams create_params(builder->browser_context_, |
82 content::BrowserContext* context = | 92 nullptr); |
83 HeadlessBrowserContextImpl::From(builder->browser_context_); | |
84 content::WebContents::CreateParams create_params(context, nullptr); | |
85 create_params.initial_size = builder->window_size_; | 93 create_params.initial_size = builder->window_size_; |
86 | 94 |
87 std::unique_ptr<HeadlessWebContentsImpl> headless_web_contents = | 95 std::unique_ptr<HeadlessWebContentsImpl> headless_web_contents = |
88 base::WrapUnique(new HeadlessWebContentsImpl( | 96 base::WrapUnique(new HeadlessWebContentsImpl( |
89 content::WebContents::Create(create_params), browser)); | 97 content::WebContents::Create(create_params), |
| 98 builder->browser_context_)); |
90 | 99 |
91 headless_web_contents->mojo_services_ = std::move(builder->mojo_services_); | 100 headless_web_contents->mojo_services_ = std::move(builder->mojo_services_); |
92 headless_web_contents->InitializeScreen(parent_window, builder->window_size_); | 101 headless_web_contents->InitializeScreen(parent_window, builder->window_size_); |
93 if (!headless_web_contents->OpenURL(builder->initial_url_)) | 102 if (!headless_web_contents->OpenURL(builder->initial_url_)) |
94 return nullptr; | 103 return nullptr; |
95 return headless_web_contents; | 104 return headless_web_contents; |
96 } | 105 } |
97 | 106 |
98 // static | 107 // static |
99 std::unique_ptr<HeadlessWebContentsImpl> | 108 std::unique_ptr<HeadlessWebContentsImpl> |
100 HeadlessWebContentsImpl::CreateFromWebContents( | 109 HeadlessWebContentsImpl::CreateFromWebContents( |
101 content::WebContents* web_contents, | 110 content::WebContents* web_contents, |
102 HeadlessBrowserImpl* browser) { | 111 HeadlessBrowserContextImpl* browser_context) { |
103 std::unique_ptr<HeadlessWebContentsImpl> headless_web_contents = | 112 std::unique_ptr<HeadlessWebContentsImpl> headless_web_contents = |
104 base::WrapUnique(new HeadlessWebContentsImpl(web_contents, browser)); | 113 base::WrapUnique( |
| 114 new HeadlessWebContentsImpl(web_contents, browser_context)); |
105 | 115 |
106 return headless_web_contents; | 116 return headless_web_contents; |
107 } | 117 } |
108 | 118 |
109 void HeadlessWebContentsImpl::InitializeScreen(aura::Window* parent_window, | 119 void HeadlessWebContentsImpl::InitializeScreen(aura::Window* parent_window, |
110 const gfx::Size& initial_size) { | 120 const gfx::Size& initial_size) { |
111 aura::Window* contents = web_contents_->GetNativeView(); | 121 aura::Window* contents = web_contents_->GetNativeView(); |
112 DCHECK(!parent_window->Contains(contents)); | 122 DCHECK(!parent_window->Contains(contents)); |
113 parent_window->AddChild(contents); | 123 parent_window->AddChild(contents); |
114 contents->Show(); | 124 contents->Show(); |
115 | 125 |
116 contents->SetBounds(gfx::Rect(initial_size)); | 126 contents->SetBounds(gfx::Rect(initial_size)); |
117 content::RenderWidgetHostView* host_view = | 127 content::RenderWidgetHostView* host_view = |
118 web_contents_->GetRenderWidgetHostView(); | 128 web_contents_->GetRenderWidgetHostView(); |
119 if (host_view) | 129 if (host_view) |
120 host_view->SetSize(initial_size); | 130 host_view->SetSize(initial_size); |
121 } | 131 } |
122 | 132 |
123 HeadlessWebContentsImpl::HeadlessWebContentsImpl( | 133 HeadlessWebContentsImpl::HeadlessWebContentsImpl( |
124 content::WebContents* web_contents, | 134 content::WebContents* web_contents, |
125 HeadlessBrowserImpl* browser) | 135 HeadlessBrowserContextImpl* browser_context) |
126 : content::WebContentsObserver(web_contents), | 136 : content::WebContentsObserver(web_contents), |
127 web_contents_delegate_(new HeadlessWebContentsImpl::Delegate(browser)), | 137 web_contents_delegate_( |
| 138 new HeadlessWebContentsImpl::Delegate(browser_context)), |
128 web_contents_(web_contents), | 139 web_contents_(web_contents), |
129 agent_host_(content::DevToolsAgentHost::GetOrCreateFor(web_contents)), | 140 agent_host_(content::DevToolsAgentHost::GetOrCreateFor(web_contents)), |
130 browser_(browser) { | 141 browser_context_(browser_context) { |
131 web_contents_->SetDelegate(web_contents_delegate_.get()); | 142 web_contents_->SetDelegate(web_contents_delegate_.get()); |
132 } | 143 } |
133 | 144 |
134 HeadlessWebContentsImpl::~HeadlessWebContentsImpl() { | 145 HeadlessWebContentsImpl::~HeadlessWebContentsImpl() { |
135 web_contents_->Close(); | 146 web_contents_->Close(); |
136 } | 147 } |
137 | 148 |
138 void HeadlessWebContentsImpl::RenderFrameCreated( | 149 void HeadlessWebContentsImpl::RenderFrameCreated( |
139 content::RenderFrameHost* render_frame_host) { | 150 content::RenderFrameHost* render_frame_host) { |
140 if (!mojo_services_.empty()) { | 151 if (!mojo_services_.empty()) { |
141 render_frame_host->GetRenderViewHost()->AllowBindings( | 152 render_frame_host->GetRenderViewHost()->AllowBindings( |
142 content::BINDINGS_POLICY_HEADLESS); | 153 content::BINDINGS_POLICY_HEADLESS); |
143 } | 154 } |
144 | 155 |
145 shell::InterfaceRegistry* interface_registry = | 156 shell::InterfaceRegistry* interface_registry = |
146 render_frame_host->GetInterfaceRegistry(); | 157 render_frame_host->GetInterfaceRegistry(); |
147 | 158 |
148 for (const MojoService& service : mojo_services_) { | 159 for (const MojoService& service : mojo_services_) { |
149 interface_registry->AddInterface(service.service_name, | 160 interface_registry->AddInterface(service.service_name, |
150 service.service_factory, | 161 service.service_factory, |
151 browser_->BrowserMainThread()); | 162 browser()->BrowserMainThread()); |
152 } | 163 } |
153 } | 164 } |
154 | 165 |
155 bool HeadlessWebContentsImpl::OpenURL(const GURL& url) { | 166 bool HeadlessWebContentsImpl::OpenURL(const GURL& url) { |
156 if (!url.is_valid()) | 167 if (!url.is_valid()) |
157 return false; | 168 return false; |
158 content::NavigationController::LoadURLParams params(url); | 169 content::NavigationController::LoadURLParams params(url); |
159 params.transition_type = ui::PageTransitionFromInt( | 170 params.transition_type = ui::PageTransitionFromInt( |
160 ui::PAGE_TRANSITION_TYPED | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR); | 171 ui::PAGE_TRANSITION_TYPED | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR); |
161 web_contents_->GetController().LoadURLWithParams(params); | 172 web_contents_->GetController().LoadURLWithParams(params); |
162 web_contents_->Focus(); | 173 web_contents_->Focus(); |
163 return true; | 174 return true; |
164 } | 175 } |
165 | 176 |
166 void HeadlessWebContentsImpl::Close() { | 177 void HeadlessWebContentsImpl::Close() { |
167 browser_->DestroyWebContents(this); | 178 browser_context()->UnregisterWebContents(this); |
| 179 browser()->DestroyWebContents(this); |
168 } | 180 } |
169 | 181 |
170 std::string HeadlessWebContentsImpl::GetDevtoolsAgentHostId() { | 182 std::string HeadlessWebContentsImpl::GetDevtoolsAgentHostId() { |
171 return agent_host_->GetId(); | 183 return agent_host_->GetId(); |
172 } | 184 } |
173 | 185 |
174 void HeadlessWebContentsImpl::AddObserver(Observer* observer) { | 186 void HeadlessWebContentsImpl::AddObserver(Observer* observer) { |
175 DCHECK(observer_map_.find(observer) == observer_map_.end()); | 187 DCHECK(observer_map_.find(observer) == observer_map_.end()); |
176 observer_map_[observer] = base::WrapUnique( | 188 observer_map_[observer] = base::WrapUnique( |
177 new WebContentsObserverAdapter(web_contents_.get(), observer)); | 189 new WebContentsObserverAdapter(web_contents_.get(), observer)); |
(...skipping 15 matching lines...) Expand all Loading... |
193 | 205 |
194 void HeadlessWebContentsImpl::DetachClient(HeadlessDevToolsClient* client) { | 206 void HeadlessWebContentsImpl::DetachClient(HeadlessDevToolsClient* client) { |
195 DCHECK(agent_host_); | 207 DCHECK(agent_host_); |
196 HeadlessDevToolsClientImpl::From(client)->DetachFromHost(agent_host_.get()); | 208 HeadlessDevToolsClientImpl::From(client)->DetachFromHost(agent_host_.get()); |
197 } | 209 } |
198 | 210 |
199 content::WebContents* HeadlessWebContentsImpl::web_contents() const { | 211 content::WebContents* HeadlessWebContentsImpl::web_contents() const { |
200 return web_contents_.get(); | 212 return web_contents_.get(); |
201 } | 213 } |
202 | 214 |
203 HeadlessWebContents::Builder::Builder(HeadlessBrowserImpl* browser) | 215 HeadlessBrowserImpl* HeadlessWebContentsImpl::browser() const { |
204 : browser_(browser), | 216 return browser_context_->browser(); |
205 browser_context_( | 217 } |
206 browser->browser_main_parts()->default_browser_context()) {} | 218 |
| 219 HeadlessBrowserContextImpl* HeadlessWebContentsImpl::browser_context() const { |
| 220 return browser_context_; |
| 221 } |
| 222 |
| 223 HeadlessWebContents::Builder::Builder( |
| 224 HeadlessBrowserContextImpl* browser_context) |
| 225 : browser_context_(browser_context) {} |
207 | 226 |
208 HeadlessWebContents::Builder::~Builder() = default; | 227 HeadlessWebContents::Builder::~Builder() = default; |
209 | 228 |
210 HeadlessWebContents::Builder::Builder(Builder&&) = default; | 229 HeadlessWebContents::Builder::Builder(Builder&&) = default; |
211 | 230 |
212 HeadlessWebContents::Builder& HeadlessWebContents::Builder::SetInitialURL( | 231 HeadlessWebContents::Builder& HeadlessWebContents::Builder::SetInitialURL( |
213 const GURL& initial_url) { | 232 const GURL& initial_url) { |
214 initial_url_ = initial_url; | 233 initial_url_ = initial_url; |
215 return *this; | 234 return *this; |
216 } | 235 } |
217 | 236 |
218 HeadlessWebContents::Builder& HeadlessWebContents::Builder::SetWindowSize( | 237 HeadlessWebContents::Builder& HeadlessWebContents::Builder::SetWindowSize( |
219 const gfx::Size& size) { | 238 const gfx::Size& size) { |
220 window_size_ = size; | 239 window_size_ = size; |
221 return *this; | 240 return *this; |
222 } | 241 } |
223 | 242 |
224 HeadlessWebContents::Builder& HeadlessWebContents::Builder::SetBrowserContext( | |
225 HeadlessBrowserContext* browser_context) { | |
226 browser_context_ = browser_context; | |
227 return *this; | |
228 } | |
229 | |
230 HeadlessWebContents::Builder& HeadlessWebContents::Builder::AddMojoService( | 243 HeadlessWebContents::Builder& HeadlessWebContents::Builder::AddMojoService( |
231 const std::string& service_name, | 244 const std::string& service_name, |
232 const base::Callback<void(mojo::ScopedMessagePipeHandle)>& | 245 const base::Callback<void(mojo::ScopedMessagePipeHandle)>& |
233 service_factory) { | 246 service_factory) { |
234 mojo_services_.emplace_back(service_name, service_factory); | 247 mojo_services_.emplace_back(service_name, service_factory); |
235 return *this; | 248 return *this; |
236 } | 249 } |
237 | 250 |
238 HeadlessWebContents* HeadlessWebContents::Builder::Build() { | 251 HeadlessWebContents* HeadlessWebContents::Builder::Build() { |
239 return browser_->CreateWebContents(this); | 252 return browser_context_->browser()->CreateWebContents(this); |
240 } | 253 } |
241 | 254 |
242 HeadlessWebContents::Builder::MojoService::MojoService() {} | 255 HeadlessWebContents::Builder::MojoService::MojoService() {} |
243 | 256 |
244 HeadlessWebContents::Builder::MojoService::MojoService( | 257 HeadlessWebContents::Builder::MojoService::MojoService( |
245 const std::string& service_name, | 258 const std::string& service_name, |
246 const base::Callback<void(mojo::ScopedMessagePipeHandle)>& service_factory) | 259 const base::Callback<void(mojo::ScopedMessagePipeHandle)>& service_factory) |
247 : service_name(service_name), service_factory(service_factory) {} | 260 : service_name(service_name), service_factory(service_factory) {} |
248 | 261 |
249 HeadlessWebContents::Builder::MojoService::~MojoService() {} | 262 HeadlessWebContents::Builder::MojoService::~MojoService() {} |
250 | 263 |
251 } // namespace headless | 264 } // namespace headless |
OLD | NEW |