1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "chrome/browser/ui/webui/devtools_ui.h"
6
7 #include <string>
8
9 #include "base/memory/ref_counted_memory.h"
10 #include "base/memory/scoped_ptr.h"
11 #include "base/strings/string_util.h"
12 #include "base/strings/stringprintf.h"
13 #include "chrome/browser/net/chrome_url_request_context.h"
14 #include "chrome/browser/profiles/profile.h"
15 #include "chrome/common/url_constants.h"
16 #include "content/public/browser/browser_thread.h"
17 #include "content/public/browser/devtools_http_handler.h"
18 #include "content/public/browser/url_data_source.h"
19 #include "content/public/browser/web_contents.h"
20 #include "content/public/browser/web_ui.h"
21 #include "net/url_request/url_fetcher.h"
22 #include "net/url_request/url_fetcher_delegate.h"
23 #include "net/url_request/url_request_context_getter.h"
24 #include "ui/base/resource/resource_bundle.h"
25
26 using content::BrowserThread;
27 using content::WebContents;
28
29 namespace {
30
PathWithoutParams(const std::string & path)31 std::string PathWithoutParams(const std::string& path) {
32 return GURL(std::string("chrome-devtools://devtools/") + path)
33 .path().substr(1);
34 }
35
36 const char kRemoteFrontendDomain[] = "chrome-devtools-frontend.appspot.com";
37 const char kRemoteFrontendBase[] =
38 "https://chrome-devtools-frontend.appspot.com/";
39 const char kHttpNotFound[] = "HTTP/1.1 404 Not Found\n\n";
40
41 #if defined(DEBUG_DEVTOOLS)
42 // Local frontend url provided by InspectUI.
43 const char kFallbackFrontendURL[] =
44 "chrome-devtools://devtools/bundled/devtools.html";
45 #else
46 // URL causing the DevTools window to display a plain text warning.
47 const char kFallbackFrontendURL[] =
48 "data:text/plain,Cannot load DevTools frontend from an untrusted origin";
49 #endif // defined(DEBUG_DEVTOOLS)
50
51 // FetchRequest ---------------------------------------------------------------
52
53 class FetchRequest : public net::URLFetcherDelegate {
54 public:
55 FetchRequest(net::URLRequestContextGetter* request_context,
56 const GURL& url,
57 const content::URLDataSource::GotDataCallback& callback);
58
59 private:
~FetchRequest()60 virtual ~FetchRequest() {}
61 virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
62 scoped_ptr<net::URLFetcher> fetcher_;
63 content::URLDataSource::GotDataCallback callback_;
64 };
65
FetchRequest(net::URLRequestContextGetter * request_context,const GURL & url,const content::URLDataSource::GotDataCallback & callback)66 FetchRequest::FetchRequest(
67 net::URLRequestContextGetter* request_context,
68 const GURL& url,
69 const content::URLDataSource::GotDataCallback& callback)
70 : callback_(callback) {
71 if (!url.is_valid()) {
72 OnURLFetchComplete(NULL);
73 return;
74 }
75
76 fetcher_.reset(net::URLFetcher::Create(url, net::URLFetcher::GET, this));
77 fetcher_->SetRequestContext(request_context);
78 fetcher_->Start();
79 }
80
OnURLFetchComplete(const net::URLFetcher * source)81 void FetchRequest::OnURLFetchComplete(const net::URLFetcher* source) {
82 std::string response;
83 if (source)
84 source->GetResponseAsString(&response);
85 else
86 response = kHttpNotFound;
87
88 callback_.Run(base::RefCountedString::TakeString(&response));
89 delete this;
90 }
91
92 // DevToolsDataSource ---------------------------------------------------------
93
GetMimeTypeForPath(const std::string & path)94 std::string GetMimeTypeForPath(const std::string& path) {
95 std::string filename = PathWithoutParams(path);
96 if (EndsWith(filename, ".html", false)) {
97 return "text/html";
98 } else if (EndsWith(filename, ".css", false)) {
99 return "text/css";
100 } else if (EndsWith(filename, ".js", false)) {
101 return "application/javascript";
102 } else if (EndsWith(filename, ".png", false)) {
103 return "image/png";
104 } else if (EndsWith(filename, ".gif", false)) {
105 return "image/gif";
106 } else if (EndsWith(filename, ".manifest", false)) {
107 return "text/cache-manifest";
108 }
109 NOTREACHED();
110 return "text/plain";
111 }
112
113 // An URLDataSource implementation that handles chrome-devtools://devtools/
114 // requests. Three types of requests could be handled based on the URL path:
115 // 1. /bundled/: bundled DevTools frontend is served.
116 // 2. /remote/: Remote DevTools frontend is served from App Engine.
117 class DevToolsDataSource : public content::URLDataSource {
118 public:
119 explicit DevToolsDataSource(net::URLRequestContextGetter* request_context);
120
121 // content::URLDataSource implementation.
122 virtual std::string GetSource() const OVERRIDE;
123
124 virtual void StartDataRequest(
125 const std::string& path,
126 int render_process_id,
127 int render_frame_id,
128 const content::URLDataSource::GotDataCallback& callback) OVERRIDE;
129
130 private:
131 // content::URLDataSource overrides.
132 virtual std::string GetMimeType(const std::string& path) const OVERRIDE;
133 virtual bool ShouldAddContentSecurityPolicy() const OVERRIDE;
134 virtual bool ShouldServeMimeTypeAsContentTypeHeader() const OVERRIDE;
135
136 // Serves bundled DevTools frontend from ResourceBundle.
137 void StartBundledDataRequest(
138 const std::string& path,
139 int render_process_id,
140 int render_frame_id,
141 const content::URLDataSource::GotDataCallback& callback);
142
143 // Serves remote DevTools frontend from hard-coded App Engine domain.
144 void StartRemoteDataRequest(
145 const std::string& path,
146 int render_process_id,
147 int render_frame_id,
148 const content::URLDataSource::GotDataCallback& callback);
149
~DevToolsDataSource()150 virtual ~DevToolsDataSource() {}
151 scoped_refptr<net::URLRequestContextGetter> request_context_;
152
153 DISALLOW_COPY_AND_ASSIGN(DevToolsDataSource);
154 };
155
DevToolsDataSource(net::URLRequestContextGetter * request_context)156 DevToolsDataSource::DevToolsDataSource(
157 net::URLRequestContextGetter* request_context)
158 : request_context_(request_context) {
159 }
160
GetSource() const161 std::string DevToolsDataSource::GetSource() const {
162 return chrome::kChromeUIDevToolsHost;
163 }
164
StartDataRequest(const std::string & path,int render_process_id,int render_frame_id,const content::URLDataSource::GotDataCallback & callback)165 void DevToolsDataSource::StartDataRequest(
166 const std::string& path,
167 int render_process_id,
168 int render_frame_id,
169 const content::URLDataSource::GotDataCallback& callback) {
170 // Serve request from local bundle.
171 std::string bundled_path_prefix(chrome::kChromeUIDevToolsBundledPath);
172 bundled_path_prefix += "/";
173 if (StartsWithASCII(path, bundled_path_prefix, false)) {
174 StartBundledDataRequest(path.substr(bundled_path_prefix.length()),
175 render_process_id, render_frame_id, callback);
176 return;
177 }
178
179 // Serve request from remote location.
180 std::string remote_path_prefix(chrome::kChromeUIDevToolsRemotePath);
181 remote_path_prefix += "/";
182 if (StartsWithASCII(path, remote_path_prefix, false)) {
183 StartRemoteDataRequest(path.substr(remote_path_prefix.length()),
184 render_process_id, render_frame_id, callback);
185 return;
186 }
187
188 callback.Run(NULL);
189 }
190
GetMimeType(const std::string & path) const191 std::string DevToolsDataSource::GetMimeType(const std::string& path) const {
192 return GetMimeTypeForPath(path);
193 }
194
ShouldAddContentSecurityPolicy() const195 bool DevToolsDataSource::ShouldAddContentSecurityPolicy() const {
196 return false;
197 }
198
ShouldServeMimeTypeAsContentTypeHeader() const199 bool DevToolsDataSource::ShouldServeMimeTypeAsContentTypeHeader() const {
200 return true;
201 }
202
StartBundledDataRequest(const std::string & path,int render_process_id,int render_frame_id,const content::URLDataSource::GotDataCallback & callback)203 void DevToolsDataSource::StartBundledDataRequest(
204 const std::string& path,
205 int render_process_id,
206 int render_frame_id,
207 const content::URLDataSource::GotDataCallback& callback) {
208 std::string filename = PathWithoutParams(path);
209
210 int resource_id =
211 content::DevToolsHttpHandler::GetFrontendResourceId(filename);
212
213 DLOG_IF(WARNING, -1 == resource_id) << "Unable to find dev tool resource: "
214 << filename << ". If you compiled with debug_devtools=1, try running"
215 " with --debug-devtools.";
216 const ResourceBundle& rb = ResourceBundle::GetSharedInstance();
217 scoped_refptr<base::RefCountedStaticMemory> bytes(rb.LoadDataResourceBytes(
218 resource_id));
219 callback.Run(bytes.get());
220 }
221
StartRemoteDataRequest(const std::string & path,int render_process_id,int render_frame_id,const content::URLDataSource::GotDataCallback & callback)222 void DevToolsDataSource::StartRemoteDataRequest(
223 const std::string& path,
224 int render_process_id,
225 int render_frame_id,
226 const content::URLDataSource::GotDataCallback& callback) {
227 GURL url = GURL(kRemoteFrontendBase + path);
228 CHECK_EQ(url.host(), kRemoteFrontendDomain);
229 new FetchRequest(request_context_, url, callback);
230 }
231
232 } // namespace
233
234 // DevToolsUI -----------------------------------------------------------------
235
236 // static
GetProxyURL(const std::string & frontend_url)237 GURL DevToolsUI::GetProxyURL(const std::string& frontend_url) {
238 GURL url(frontend_url);
239 if (!url.is_valid() || url.host() != kRemoteFrontendDomain)
240 return GURL(kFallbackFrontendURL);
241 return GURL(base::StringPrintf("%s://%s/%s/%s",
242 content::kChromeDevToolsScheme,
243 chrome::kChromeUIDevToolsHost,
244 chrome::kChromeUIDevToolsRemotePath,
245 url.path().substr(1).c_str()));
246 }
247
DevToolsUI(content::WebUI * web_ui)248 DevToolsUI::DevToolsUI(content::WebUI* web_ui)
249 : WebUIController(web_ui) {
250 web_ui->SetBindings(0);
251 Profile* profile = Profile::FromWebUI(web_ui);
252 content::URLDataSource::Add(
253 profile,
254 new DevToolsDataSource(profile->GetRequestContext()));
255 }
256