Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(589)

Side by Side Diff: headless/lib/browser/headless_devtools_manager_delegate.cc

Issue 2626823003: [headless] Add default browser context to HeadlessBrowser. (Closed)
Patch Set: Address Alex' comments + fix vtable. Created 3 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2016 The Chromium Authors. All rights reserved. 1 // Copyright 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 "headless/lib/browser/headless_devtools_manager_delegate.h" 5 #include "headless/lib/browser/headless_devtools_manager_delegate.h"
6 6
7 #include <string> 7 #include <string>
8 #include <utility> 8 #include <utility>
9 9
10 #include "content/public/browser/browser_thread.h" 10 #include "content/public/browser/browser_thread.h"
11 #include "content/public/browser/devtools_agent_host.h" 11 #include "content/public/browser/devtools_agent_host.h"
12 #include "content/public/browser/devtools_frontend_host.h" 12 #include "content/public/browser/devtools_frontend_host.h"
13 #include "content/public/browser/web_contents.h" 13 #include "content/public/browser/web_contents.h"
14 #include "headless/grit/headless_lib_resources.h" 14 #include "headless/grit/headless_lib_resources.h"
15 #include "headless/lib/browser/headless_browser_context_impl.h" 15 #include "headless/lib/browser/headless_browser_context_impl.h"
16 #include "headless/lib/browser/headless_browser_impl.h" 16 #include "headless/lib/browser/headless_browser_impl.h"
17 #include "headless/lib/browser/headless_web_contents_impl.h" 17 #include "headless/lib/browser/headless_web_contents_impl.h"
18 #include "headless/public/devtools/domains/target.h" 18 #include "headless/public/devtools/domains/target.h"
19 #include "ui/base/resource/resource_bundle.h" 19 #include "ui/base/resource/resource_bundle.h"
20 20
21 namespace headless { 21 namespace headless {
22 22
23 namespace {
24 const char kIdParam[] = "id";
25 const char kResultParam[] = "result";
26 const char kErrorParam[] = "error";
27 const char kErrorCodeParam[] = "code";
28 const char kErrorMessageParam[] = "message";
29
30 // JSON RPC 2.0 spec: http://www.jsonrpc.org/specification#error_object
31 enum Error {
32 kErrorInvalidParam = -32602
33 };
34
35 std::unique_ptr<base::DictionaryValue> CreateSuccessResponse(
36 int command_id,
37 std::unique_ptr<base::Value> result) {
38 if (!result)
39 result.reset(new base::DictionaryValue());
40
41 std::unique_ptr<base::DictionaryValue> response(new base::DictionaryValue());
42 response->SetInteger(kIdParam, command_id);
43 response->Set(kResultParam, std::move(result));
44 return response;
45 }
46
47 std::unique_ptr<base::DictionaryValue> CreateInvalidParamResponse(
48 int command_id,
49 const std::string& param) {
50 std::unique_ptr<base::DictionaryValue> error_object(
51 new base::DictionaryValue());
52 error_object->SetInteger(kErrorCodeParam, kErrorInvalidParam);
53 error_object->SetString(
54 kErrorMessageParam,
55 base::StringPrintf("Missing or invalid '%s' parameter", param.c_str()));
56
57 std::unique_ptr<base::DictionaryValue> response(new base::DictionaryValue());
58 response->Set(kErrorParam, std::move(error_object));
59 return response;
60 }
61 } // namespace
62
23 HeadlessDevToolsManagerDelegate::HeadlessDevToolsManagerDelegate( 63 HeadlessDevToolsManagerDelegate::HeadlessDevToolsManagerDelegate(
24 base::WeakPtr<HeadlessBrowserImpl> browser) 64 base::WeakPtr<HeadlessBrowserImpl> browser)
25 : browser_(std::move(browser)), default_browser_context_(nullptr) { 65 : browser_(std::move(browser)) {
26 command_map_["Target.createTarget"] = 66 command_map_["Target.createTarget"] =
27 &HeadlessDevToolsManagerDelegate::CreateTarget; 67 &HeadlessDevToolsManagerDelegate::CreateTarget;
28 command_map_["Target.closeTarget"] = 68 command_map_["Target.closeTarget"] =
29 &HeadlessDevToolsManagerDelegate::CloseTarget; 69 &HeadlessDevToolsManagerDelegate::CloseTarget;
30 command_map_["Target.createBrowserContext"] = 70 command_map_["Target.createBrowserContext"] =
31 &HeadlessDevToolsManagerDelegate::CreateBrowserContext; 71 &HeadlessDevToolsManagerDelegate::CreateBrowserContext;
32 command_map_["Target.disposeBrowserContext"] = 72 command_map_["Target.disposeBrowserContext"] =
33 &HeadlessDevToolsManagerDelegate::DisposeBrowserContext; 73 &HeadlessDevToolsManagerDelegate::DisposeBrowserContext;
34 } 74 }
35 75
(...skipping 12 matching lines...) Expand all
48 const base::DictionaryValue* params = nullptr; 88 const base::DictionaryValue* params = nullptr;
49 if (!command->GetInteger("id", &id) || 89 if (!command->GetInteger("id", &id) ||
50 !command->GetString("method", &method) || 90 !command->GetString("method", &method) ||
51 !command->GetDictionary("params", &params)) { 91 !command->GetDictionary("params", &params)) {
52 return nullptr; 92 return nullptr;
53 } 93 }
54 auto find_it = command_map_.find(method); 94 auto find_it = command_map_.find(method);
55 if (find_it == command_map_.end()) 95 if (find_it == command_map_.end())
56 return nullptr; 96 return nullptr;
57 CommandMemberFnPtr command_fn_ptr = find_it->second; 97 CommandMemberFnPtr command_fn_ptr = find_it->second;
58 std::unique_ptr<base::Value> cmd_result(((this)->*command_fn_ptr)(params)); 98 std::unique_ptr<base::DictionaryValue> cmd_result(
59 if (!cmd_result) 99 ((this)->*command_fn_ptr)(id, params));
60 return nullptr; 100 return cmd_result.release();
61
62 std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
63 result->SetInteger("id", id);
64 result->Set("result", std::move(cmd_result));
65 return result.release();
66 } 101 }
67 102
68 std::string HeadlessDevToolsManagerDelegate::GetDiscoveryPageHTML() { 103 std::string HeadlessDevToolsManagerDelegate::GetDiscoveryPageHTML() {
69 return ResourceBundle::GetSharedInstance().GetRawDataResource( 104 return ResourceBundle::GetSharedInstance()
70 IDR_HEADLESS_LIB_DEVTOOLS_DISCOVERY_PAGE).as_string(); 105 .GetRawDataResource(IDR_HEADLESS_LIB_DEVTOOLS_DISCOVERY_PAGE)
106 .as_string();
71 } 107 }
72 108
73 std::string HeadlessDevToolsManagerDelegate::GetFrontendResource( 109 std::string HeadlessDevToolsManagerDelegate::GetFrontendResource(
74 const std::string& path) { 110 const std::string& path) {
75 return content::DevToolsFrontendHost::GetFrontendResource(path).as_string(); 111 return content::DevToolsFrontendHost::GetFrontendResource(path).as_string();
76 } 112 }
77 113
78 std::unique_ptr<base::Value> HeadlessDevToolsManagerDelegate::CreateTarget( 114 std::unique_ptr<base::DictionaryValue>
115 HeadlessDevToolsManagerDelegate::CreateTarget(
116 int command_id,
79 const base::DictionaryValue* params) { 117 const base::DictionaryValue* params) {
80 std::string url; 118 std::string url;
81 std::string browser_context_id; 119 std::string browser_context_id;
82 int width = browser_->options()->window_size.width(); 120 int width = browser_->options()->window_size.width();
83 int height = browser_->options()->window_size.height(); 121 int height = browser_->options()->window_size.height();
84 params->GetString("url", &url); 122 params->GetString("url", &url);
85 params->GetString("browserContextId", &browser_context_id); 123 params->GetString("browserContextId", &browser_context_id);
86 params->GetInteger("width", &width); 124 params->GetInteger("width", &width);
87 params->GetInteger("height", &height); 125 params->GetInteger("height", &height);
88 126
89 // TODO(alexclarke): Should we fail when user passes incorrect id?
90 HeadlessBrowserContext* context = 127 HeadlessBrowserContext* context =
91 browser_->GetBrowserContextForId(browser_context_id); 128 browser_->GetBrowserContextForId(browser_context_id);
92 if (!context) { 129 if (!browser_context_id.empty()) {
93 if (!default_browser_context_) { 130 context = browser_->GetBrowserContextForId(browser_context_id);
94 default_browser_context_ = 131 } else {
95 browser_->CreateBrowserContextBuilder().Build(); 132 context = browser_->GetDefaultBrowserContext();
96 }
97 context = default_browser_context_;
98 } 133 }
99 134
135 if (!context)
136 return CreateInvalidParamResponse(command_id, "browserContextId");
137
100 HeadlessWebContentsImpl* web_contents_impl = 138 HeadlessWebContentsImpl* web_contents_impl =
101 HeadlessWebContentsImpl::From(context->CreateWebContentsBuilder() 139 HeadlessWebContentsImpl::From(context->CreateWebContentsBuilder()
102 .SetInitialURL(GURL(url)) 140 .SetInitialURL(GURL(url))
103 .SetWindowSize(gfx::Size(width, height)) 141 .SetWindowSize(gfx::Size(width, height))
104 .Build()); 142 .Build());
105 143
106 return target::CreateTargetResult::Builder() 144 std::unique_ptr<base::Value> result(
107 .SetTargetId(web_contents_impl->GetDevToolsAgentHostId()) 145 target::CreateTargetResult::Builder()
108 .Build() 146 .SetTargetId(web_contents_impl->GetDevToolsAgentHostId())
109 ->Serialize(); 147 .Build()
148 ->Serialize());
149 return CreateSuccessResponse(command_id, std::move(result));
110 } 150 }
111 151
112 std::unique_ptr<base::Value> HeadlessDevToolsManagerDelegate::CloseTarget( 152 std::unique_ptr<base::DictionaryValue>
153 HeadlessDevToolsManagerDelegate::CloseTarget(
154 int command_id,
113 const base::DictionaryValue* params) { 155 const base::DictionaryValue* params) {
114 std::string target_id; 156 std::string target_id;
115 if (!params->GetString("targetId", &target_id)) { 157 if (!params->GetString("targetId", &target_id))
116 return nullptr; 158 return CreateInvalidParamResponse(command_id, "targetId");
117 }
118 HeadlessWebContents* web_contents = 159 HeadlessWebContents* web_contents =
119 browser_->GetWebContentsForDevToolsAgentHostId(target_id); 160 browser_->GetWebContentsForDevToolsAgentHostId(target_id);
120 bool success = false; 161 bool success = false;
121 if (web_contents) { 162 if (web_contents) {
122 web_contents->Close(); 163 web_contents->Close();
123 success = true; 164 success = true;
124 } 165 }
125 return target::CloseTargetResult::Builder() 166 std::unique_ptr<base::Value> result(target::CloseTargetResult::Builder()
126 .SetSuccess(success) 167 .SetSuccess(success)
127 .Build() 168 .Build()
128 ->Serialize(); 169 ->Serialize());
170 return CreateSuccessResponse(command_id, std::move(result));
129 } 171 }
130 172
131 std::unique_ptr<base::Value> 173 std::unique_ptr<base::DictionaryValue>
132 HeadlessDevToolsManagerDelegate::CreateBrowserContext( 174 HeadlessDevToolsManagerDelegate::CreateBrowserContext(
175 int command_id,
133 const base::DictionaryValue* params) { 176 const base::DictionaryValue* params) {
134 HeadlessBrowserContext* browser_context = 177 HeadlessBrowserContext* browser_context =
135 browser_->CreateBrowserContextBuilder().Build(); 178 browser_->CreateBrowserContextBuilder().Build();
136 179
137 std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue()); 180 std::unique_ptr<base::Value> result(
138 return target::CreateBrowserContextResult::Builder() 181 target::CreateBrowserContextResult::Builder()
139 .SetBrowserContextId(browser_context->Id()) 182 .SetBrowserContextId(browser_context->Id())
140 .Build() 183 .Build()
141 ->Serialize(); 184 ->Serialize());
185 return CreateSuccessResponse(command_id, std::move(result));
142 } 186 }
143 187
144 std::unique_ptr<base::Value> 188 std::unique_ptr<base::DictionaryValue>
145 HeadlessDevToolsManagerDelegate::DisposeBrowserContext( 189 HeadlessDevToolsManagerDelegate::DisposeBrowserContext(
190 int command_id,
146 const base::DictionaryValue* params) { 191 const base::DictionaryValue* params) {
147 std::string browser_context_id; 192 std::string browser_context_id;
148 if (!params->GetString("browserContextId", &browser_context_id)) { 193 if (!params->GetString("browserContextId", &browser_context_id))
149 return nullptr; 194 return CreateInvalidParamResponse(command_id, "browserContextId");
150 }
151 HeadlessBrowserContext* context = 195 HeadlessBrowserContext* context =
152 browser_->GetBrowserContextForId(browser_context_id); 196 browser_->GetBrowserContextForId(browser_context_id);
153 197
154 bool success = false; 198 bool success = false;
155 if (context && context != default_browser_context_ && 199 if (context && context != browser_->GetDefaultBrowserContext() &&
156 context->GetAllWebContents().empty()) { 200 context->GetAllWebContents().empty()) {
157 success = true; 201 success = true;
158 context->Close(); 202 context->Close();
159 } 203 }
160 204
161 return target::DisposeBrowserContextResult::Builder() 205 std::unique_ptr<base::Value> result(
162 .SetSuccess(success) 206 target::DisposeBrowserContextResult::Builder()
163 .Build() 207 .SetSuccess(success)
164 ->Serialize(); 208 .Build()
209 ->Serialize());
210 return CreateSuccessResponse(command_id, std::move(result));
165 } 211 }
166 212
167 } // namespace headless 213 } // namespace headless
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698