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
3 // found in the LICENSE file.
4
5 #include "chrome/browser/ui/webui/extensions/extension_error_ui_util.h"
6
7 #include <string>
8
9 #include "base/bind.h"
10 #include "base/file_util.h"
11 #include "base/files/file_path.h"
12 #include "base/location.h"
13 #include "base/strings/string16.h"
14 #include "base/strings/utf_string_conversions.h"
15 #include "base/threading/sequenced_worker_pool.h"
16 #include "base/values.h"
17 #include "chrome/browser/devtools/devtools_window.h"
18 #include "chrome/browser/profiles/profile.h"
19 #include "chrome/browser/ui/browser.h"
20 #include "chrome/browser/ui/browser_finder.h"
21 #include "chrome/browser/ui/tabs/tab_strip_model.h"
22 #include "content/public/browser/browser_thread.h"
23 #include "content/public/browser/render_view_host.h"
24 #include "content/public/browser/web_contents.h"
25 #include "extensions/browser/extension_error.h"
26 #include "extensions/browser/extension_registry.h"
27 #include "extensions/browser/file_highlighter.h"
28 #include "extensions/common/constants.h"
29 #include "extensions/common/extension.h"
30
31 namespace extensions {
32 namespace error_ui_util {
33
34 namespace {
35
36 // Keys for objects passed to and from extension error UI.
37 const char kPathSuffixKey[] = "pathSuffix";
38 const char kTitleKey[] = "title";
39
ReadFileToString(const base::FilePath & path)40 std::string ReadFileToString(const base::FilePath& path) {
41 std::string data;
42 base::ReadFileToString(path, &data);
43 return data;
44 }
45
GetManifestFileCallback(base::DictionaryValue * results,const std::string & key,const std::string & specific,const RequestFileSourceCallback & response,const std::string & contents)46 void GetManifestFileCallback(base::DictionaryValue* results,
47 const std::string& key,
48 const std::string& specific,
49 const RequestFileSourceCallback& response,
50 const std::string& contents) {
51 ManifestHighlighter highlighter(contents, key, specific);
52 highlighter.SetHighlightedRegions(results);
53 response.Run(*results);
54 }
55
GetSourceFileCallback(base::DictionaryValue * results,int line_number,const RequestFileSourceCallback & response,const std::string & contents)56 void GetSourceFileCallback(base::DictionaryValue* results,
57 int line_number,
58 const RequestFileSourceCallback& response,
59 const std::string& contents) {
60 SourceHighlighter highlighter(contents, line_number);
61 highlighter.SetHighlightedRegions(results);
62 response.Run(*results);
63 }
64
65 } // namespace
66
HandleRequestFileSource(const base::DictionaryValue * args,Profile * profile,const RequestFileSourceCallback & response)67 void HandleRequestFileSource(const base::DictionaryValue* args,
68 Profile* profile,
69 const RequestFileSourceCallback& response) {
70 // Three required arguments: extension_id, path_suffix, and error_message.
71 std::string extension_id;
72 base::FilePath::StringType path_suffix_string;
73 base::string16 error_message;
74
75 if (!args->GetString(kPathSuffixKey, &path_suffix_string) ||
76 !args->GetString(ExtensionError::kExtensionIdKey, &extension_id) ||
77 !args->GetString(ExtensionError::kMessageKey, &error_message)) {
78 NOTREACHED();
79 return;
80 }
81
82 const Extension* extension =
83 ExtensionRegistry::Get(profile)->GetExtensionById(
84 extension_id, ExtensionRegistry::EVERYTHING);
85
86 if (!extension) {
87 NOTREACHED();
88 return;
89 }
90
91 // Under no circumstances should we ever need to reference a file outside of
92 // the extension's directory. If it tries to, abort.
93 base::FilePath path_suffix(path_suffix_string);
94 if (path_suffix.ReferencesParent())
95 return;
96
97 base::FilePath path = extension->path().Append(path_suffix);
98
99 // Setting the title and the error message is the same for all file types.
100 scoped_ptr<base::DictionaryValue> results(new base::DictionaryValue);
101 results->SetString(kTitleKey,
102 base::UTF8ToUTF16(extension->name()) +
103 base::ASCIIToUTF16(": ") +
104 path.BaseName().LossyDisplayName());
105 results->SetString(ExtensionError::kMessageKey, error_message);
106
107 base::Callback<void(const std::string&)> reply;
108 if (path_suffix_string == kManifestFilename) {
109 std::string manifest_key;
110 if (!args->GetString(ManifestError::kManifestKeyKey, &manifest_key)) {
111 NOTREACHED();
112 return;
113 }
114
115 // A "specific" location is optional.
116 std::string specific;
117 args->GetString(ManifestError::kManifestSpecificKey, &specific);
118
119 reply = base::Bind(&GetManifestFileCallback,
120 base::Owned(results.release()),
121 manifest_key,
122 specific,
123 response);
124 } else {
125 int line_number = 0;
126 args->GetInteger(RuntimeError::kLineNumberKey, &line_number);
127
128 reply = base::Bind(&GetSourceFileCallback,
129 base::Owned(results.release()),
130 line_number,
131 response);
132 }
133
134 base::PostTaskAndReplyWithResult(content::BrowserThread::GetBlockingPool(),
135 FROM_HERE,
136 base::Bind(&ReadFileToString, path),
137 reply);
138 }
139
HandleOpenDevTools(const base::DictionaryValue * args)140 void HandleOpenDevTools(const base::DictionaryValue* args) {
141 int render_process_id = 0;
142 int render_view_id = 0;
143
144 // The render view and render process ids are required.
145 if (!args->GetInteger(RuntimeError::kRenderProcessIdKey,
146 &render_process_id) ||
147 !args->GetInteger(RuntimeError::kRenderViewIdKey, &render_view_id)) {
148 NOTREACHED();
149 return;
150 }
151
152 content::RenderViewHost* rvh =
153 content::RenderViewHost::FromID(render_process_id, render_view_id);
154
155 // It's possible that the render view was closed since we last updated the
156 // links. Handle this gracefully.
157 if (!rvh)
158 return;
159
160 // If we include a url, we should inspect it specifically (and not just the
161 // render view).
162 base::string16 url;
163 if (args->GetString(RuntimeError::kUrlKey, &url)) {
164 // Line and column numbers are optional; default to the first line.
165 int line_number = 1;
166 int column_number = 1;
167 args->GetInteger(RuntimeError::kLineNumberKey, &line_number);
168 args->GetInteger(RuntimeError::kColumnNumberKey, &column_number);
169
170 // Line/column numbers are reported in display-friendly 1-based numbers,
171 // but are inspected in zero-based numbers.
172 DevToolsWindow::OpenDevToolsWindow(
173 rvh,
174 DevToolsToggleAction::Reveal(url, line_number - 1, column_number - 1));
175 } else {
176 DevToolsWindow::OpenDevToolsWindow(rvh);
177 }
178
179 // Once we open the inspector, we focus on the appropriate tab...
180 content::WebContents* web_contents =
181 content::WebContents::FromRenderViewHost(rvh);
182 Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
183
184 // ... but some pages (popups and apps) don't have tabs, and some (background
185 // pages) don't have an associated browser. For these, the inspector opens in
186 // a new window, and our work is done.
187 if (!browser || !browser->is_type_tabbed())
188 return;
189
190 TabStripModel* tab_strip = browser->tab_strip_model();
191 tab_strip->ActivateTabAt(tab_strip->GetIndexOfWebContents(web_contents),
192 false); // Not through direct user gesture.
193 }
194
195 } // namespace error_ui_util
196 } // namespace extensions
197