1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
|
// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/extensions/extension_dom_ui.h"
#include <set>
#include "net/base/file_stream.h"
#include "base/string_util.h"
#include "base/utf_string_conversions.h"
#include "chrome/browser/browser.h"
#include "chrome/browser/browser_list.h"
#include "chrome/browser/chrome_thread.h"
#include "chrome/browser/extensions/extension_bookmark_manager_api.h"
#include "chrome/browser/extensions/extensions_service.h"
#include "chrome/browser/extensions/image_loading_tracker.h"
#include "chrome/browser/prefs/pref_service.h"
#include "chrome/browser/profile.h"
#include "chrome/browser/renderer_host/render_widget_host_view.h"
#include "chrome/browser/tab_contents/tab_contents.h"
#include "chrome/common/bindings_policy.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/page_transition_types.h"
#include "chrome/common/extensions/extension.h"
#include "chrome/common/extensions/extension_constants.h"
#include "chrome/common/extensions/extension_resource.h"
#include "chrome/common/url_constants.h"
#include "gfx/codec/png_codec.h"
#include "gfx/favicon_size.h"
#include "third_party/skia/include/core/SkBitmap.h"
namespace {
// De-dupes the items in |list|. Assumes the values are strings.
void CleanUpDuplicates(ListValue* list) {
std::set<std::string> seen_values;
// Loop backwards as we may be removing items.
for (size_t i = list->GetSize() - 1; (i + 1) > 0; --i) {
std::string value;
if (!list->GetString(i, &value)) {
NOTREACHED();
continue;
}
if (seen_values.find(value) == seen_values.end())
seen_values.insert(value);
else
list->Remove(i, NULL);
}
}
// Helper class that is used to track the loading of the favicon of an
// extension.
class ExtensionDOMUIImageLoadingTracker : public ImageLoadingTracker::Observer {
public:
ExtensionDOMUIImageLoadingTracker(Profile* profile,
FaviconService::GetFaviconRequest* request,
const GURL& page_url)
: ALLOW_THIS_IN_INITIALIZER_LIST(tracker_(this)),
request_(request),
extension_(NULL) {
// Even when the extensions service is enabled by default, it's still
// disabled in incognito mode.
ExtensionsService* service = profile->GetExtensionsService();
if (service)
extension_ = service->GetExtensionByURL(page_url);
}
void Init() {
if (extension_) {
ExtensionResource icon_resource =
extension_->GetIconResource(Extension::EXTENSION_ICON_BITTY);
tracker_.LoadImage(extension_, icon_resource,
gfx::Size(kFavIconSize, kFavIconSize),
ImageLoadingTracker::DONT_CACHE);
} else {
ForwardResult(NULL);
}
}
virtual void OnImageLoaded(SkBitmap* image, ExtensionResource resource,
int index) {
if (image) {
std::vector<unsigned char> image_data;
if (!gfx::PNGCodec::EncodeBGRASkBitmap(*image, false, &image_data)) {
NOTREACHED() << "Could not encode extension favicon";
}
ForwardResult(RefCountedBytes::TakeVector(&image_data));
} else {
ForwardResult(NULL);
}
}
private:
~ExtensionDOMUIImageLoadingTracker() {}
// Forwards the result on the request. If no favicon was available then
// |icon_data| may be backed by NULL. Once the result has been forwarded the
// instance is deleted.
void ForwardResult(scoped_refptr<RefCountedMemory> icon_data) {
bool know_icon = icon_data.get() != NULL && icon_data->size() > 0;
request_->ForwardResultAsync(
FaviconService::FaviconDataCallback::TupleType(request_->handle(),
know_icon, icon_data, false, GURL()));
delete this;
}
ImageLoadingTracker tracker_;
scoped_refptr<FaviconService::GetFaviconRequest> request_;
Extension* extension_;
DISALLOW_COPY_AND_ASSIGN(ExtensionDOMUIImageLoadingTracker);
};
} // namespace
const char ExtensionDOMUI::kExtensionURLOverrides[] =
"extensions.chrome_url_overrides";
ExtensionDOMUI::ExtensionDOMUI(TabContents* tab_contents, GURL url)
: DOMUI(tab_contents) {
ExtensionsService* service = tab_contents->profile()->GetExtensionsService();
Extension* extension = service->GetExtensionByURL(url);
if (!extension)
extension = service->GetExtensionByWebExtent(url);
DCHECK(extension);
// Only hide the url for internal pages (e.g. chrome-extension or packaged
// component apps like bookmark manager.
should_hide_url_ = !extension->is_app();
bindings_ = BindingsPolicy::EXTENSION;
// Bind externalHost to Extension DOMUI loaded in Chrome Frame.
const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
if (browser_command_line.HasSwitch(switches::kChromeFrame))
bindings_ |= BindingsPolicy::EXTERNAL_HOST;
// For chrome:// overrides, some of the defaults are a little different.
GURL effective_url = tab_contents->GetURL();
if (effective_url.SchemeIs(chrome::kChromeUIScheme) &&
effective_url.host() == chrome::kChromeUINewTabHost) {
focus_location_bar_by_default_ = true;
}
}
void ExtensionDOMUI::ResetExtensionFunctionDispatcher(
RenderViewHost* render_view_host) {
// Use the NavigationController to get the URL rather than the TabContents
// since this is the real underlying URL (see HandleChromeURLOverride).
NavigationController& controller = tab_contents()->controller();
const GURL& url = controller.GetActiveEntry()->url();
extension_function_dispatcher_.reset(
ExtensionFunctionDispatcher::Create(render_view_host, this, url));
DCHECK(extension_function_dispatcher_.get());
}
void ExtensionDOMUI::ResetExtensionBookmarkManagerEventRouter() {
// Hack: A few things we specialize just for the bookmark manager.
if (extension_function_dispatcher_->extension_id() ==
extension_misc::kBookmarkManagerId) {
extension_bookmark_manager_event_router_.reset(
new ExtensionBookmarkManagerEventRouter(GetProfile(), tab_contents()));
link_transition_type_ = PageTransition::AUTO_BOOKMARK;
}
}
void ExtensionDOMUI::RenderViewCreated(RenderViewHost* render_view_host) {
ResetExtensionFunctionDispatcher(render_view_host);
ResetExtensionBookmarkManagerEventRouter();
}
void ExtensionDOMUI::RenderViewReused(RenderViewHost* render_view_host) {
ResetExtensionFunctionDispatcher(render_view_host);
ResetExtensionBookmarkManagerEventRouter();
}
void ExtensionDOMUI::ProcessDOMUIMessage(
const ViewHostMsg_DomMessage_Params& params) {
extension_function_dispatcher_->HandleRequest(params);
}
Browser* ExtensionDOMUI::GetBrowser() const {
// TODO(beng): This is an improper direct dependency on Browser. Route this
// through some sort of delegate.
return BrowserList::FindBrowserWithProfile(DOMUI::GetProfile());
}
Profile* ExtensionDOMUI::GetProfile() {
return DOMUI::GetProfile();
}
gfx::NativeWindow ExtensionDOMUI::GetCustomFrameNativeWindow() {
if (GetBrowser())
return NULL;
// If there was no browser associated with the function dispatcher delegate,
// then this DOMUI may be hosted in an ExternalTabContainer, and a framing
// window will be accessible through the tab_contents.
TabContentsDelegate* tab_contents_delegate = tab_contents()->delegate();
if (tab_contents_delegate)
return tab_contents_delegate->GetFrameNativeWindow();
else
return NULL;
}
gfx::NativeView ExtensionDOMUI::GetNativeViewOfHost() {
return tab_contents()->GetRenderWidgetHostView()->GetNativeView();
}
////////////////////////////////////////////////////////////////////////////////
// chrome:// URL overrides
// static
void ExtensionDOMUI::RegisterUserPrefs(PrefService* prefs) {
prefs->RegisterDictionaryPref(kExtensionURLOverrides);
}
// static
bool ExtensionDOMUI::HandleChromeURLOverride(GURL* url, Profile* profile) {
if (!url->SchemeIs(chrome::kChromeUIScheme))
return false;
const DictionaryValue* overrides =
profile->GetPrefs()->GetDictionary(kExtensionURLOverrides);
std::string page = url->host();
ListValue* url_list;
if (!overrides || !overrides->GetList(page, &url_list))
return false;
ExtensionsService* service = profile->GetExtensionsService();
if (!service->is_ready()) {
// TODO(erikkay) So far, it looks like extensions load before the new tab
// page. I don't know if we have anything that enforces this, so add this
// check for safety.
NOTREACHED() << "Chrome URL override requested before extensions loaded";
return false;
}
size_t i = 0;
while (i < url_list->GetSize()) {
Value* val = NULL;
url_list->Get(i, &val);
// Verify that the override value is good. If not, unregister it and find
// the next one.
std::string override;
if (!val->GetAsString(&override)) {
NOTREACHED();
UnregisterChromeURLOverride(page, profile, val);
continue;
}
GURL extension_url(override);
if (!extension_url.is_valid()) {
NOTREACHED();
UnregisterChromeURLOverride(page, profile, val);
continue;
}
// Verify that the extension that's being referred to actually exists.
Extension* extension = service->GetExtensionByURL(extension_url);
if (!extension) {
// This can currently happen if you use --load-extension one run, and
// then don't use it the next. It could also happen if an extension
// were deleted directly from the filesystem, etc.
LOG(WARNING) << "chrome URL override present for non-existant extension";
UnregisterChromeURLOverride(page, profile, val);
continue;
}
// We can't handle chrome-extension URLs in incognito mode unless the
// extension uses split mode.
bool incognito_override_allowed =
extension->incognito_split_mode() &&
service->IsIncognitoEnabled(extension);
if (profile->IsOffTheRecord() && !incognito_override_allowed) {
++i;
continue;
}
*url = extension_url;
return true;
}
return false;
}
// static
void ExtensionDOMUI::RegisterChromeURLOverrides(
Profile* profile, const Extension::URLOverrideMap& overrides) {
if (overrides.empty())
return;
PrefService* prefs = profile->GetPrefs();
DictionaryValue* all_overrides =
prefs->GetMutableDictionary(kExtensionURLOverrides);
// For each override provided by the extension, add it to the front of
// the override list if it's not already in the list.
Extension::URLOverrideMap::const_iterator iter = overrides.begin();
for (; iter != overrides.end(); ++iter) {
const std::string& key = iter->first;
ListValue* page_overrides;
if (!all_overrides->GetList(key, &page_overrides)) {
page_overrides = new ListValue();
all_overrides->Set(key, page_overrides);
} else {
CleanUpDuplicates(page_overrides);
// Verify that the override isn't already in the list.
ListValue::iterator i = page_overrides->begin();
for (; i != page_overrides->end(); ++i) {
std::string override_val;
if (!(*i)->GetAsString(&override_val)) {
NOTREACHED();
continue;
}
if (override_val == iter->second.spec())
break;
}
// This value is already in the list, leave it alone.
if (i != page_overrides->end())
continue;
}
// Insert the override at the front of the list. Last registered override
// wins.
page_overrides->Insert(0, new StringValue(iter->second.spec()));
}
}
// static
void ExtensionDOMUI::UnregisterAndReplaceOverride(const std::string& page,
Profile* profile, ListValue* list, Value* override) {
int index = list->Remove(*override);
if (index == 0) {
// This is the active override, so we need to find all existing
// tabs for this override and get them to reload the original URL.
for (TabContentsIterator iterator; !iterator.done(); ++iterator) {
TabContents* tab = *iterator;
if (tab->profile() != profile)
continue;
GURL url = tab->GetURL();
if (!url.SchemeIs(chrome::kChromeUIScheme) || url.host() != page)
continue;
// Don't use Reload() since |url| isn't the same as the internal URL
// that NavigationController has.
tab->controller().LoadURL(url, url, PageTransition::RELOAD);
}
}
}
// static
void ExtensionDOMUI::UnregisterChromeURLOverride(const std::string& page,
Profile* profile, Value* override) {
if (!override)
return;
PrefService* prefs = profile->GetPrefs();
DictionaryValue* all_overrides =
prefs->GetMutableDictionary(kExtensionURLOverrides);
ListValue* page_overrides;
if (!all_overrides->GetList(page, &page_overrides)) {
// If it's being unregistered, it should already be in the list.
NOTREACHED();
return;
} else {
UnregisterAndReplaceOverride(page, profile, page_overrides, override);
}
}
// static
void ExtensionDOMUI::UnregisterChromeURLOverrides(
Profile* profile, const Extension::URLOverrideMap& overrides) {
if (overrides.empty())
return;
PrefService* prefs = profile->GetPrefs();
DictionaryValue* all_overrides =
prefs->GetMutableDictionary(kExtensionURLOverrides);
Extension::URLOverrideMap::const_iterator iter = overrides.begin();
for (; iter != overrides.end(); ++iter) {
const std::string& page = iter->first;
ListValue* page_overrides;
if (!all_overrides->GetList(page, &page_overrides)) {
// If it's being unregistered, it should already be in the list.
NOTREACHED();
continue;
} else {
StringValue override(iter->second.spec());
UnregisterAndReplaceOverride(iter->first, profile,
page_overrides, &override);
}
}
}
// static
void ExtensionDOMUI::GetFaviconForURL(Profile* profile,
FaviconService::GetFaviconRequest* request, const GURL& page_url) {
// tracker deletes itself when done.
ExtensionDOMUIImageLoadingTracker* tracker =
new ExtensionDOMUIImageLoadingTracker(profile, request, page_url);
tracker->Init();
}
|