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/media_galleries/media_galleries_preferences.h"
6
7 #include "base/base_paths_posix.h"
8 #include "base/callback.h"
9 #include "base/i18n/time_formatting.h"
10 #include "base/path_service.h"
11 #include "base/prefs/pref_service.h"
12 #include "base/prefs/scoped_user_pref_update.h"
13 #include "base/stl_util.h"
14 #include "base/strings/string16.h"
15 #include "base/strings/string_number_conversions.h"
16 #include "base/strings/utf_string_conversions.h"
17 #include "base/values.h"
18 #include "chrome/browser/browser_process.h"
19 #include "chrome/browser/extensions/api/media_galleries_private/media_galleries_private_api.h"
20 #include "chrome/browser/extensions/extension_service.h"
21 #include "chrome/browser/extensions/extension_system.h"
22 #include "chrome/browser/media_galleries/fileapi/iapps_finder.h"
23 #include "chrome/browser/media_galleries/fileapi/picasa_finder.h"
24 #include "chrome/browser/media_galleries/media_file_system_registry.h"
25 #include "chrome/browser/media_galleries/media_galleries_histograms.h"
26 #include "chrome/browser/profiles/profile.h"
27 #include "chrome/browser/storage_monitor/media_storage_util.h"
28 #include "chrome/browser/storage_monitor/storage_monitor.h"
29 #include "chrome/common/chrome_paths.h"
30 #include "chrome/common/extensions/permissions/media_galleries_permission.h"
31 #include "chrome/common/pref_names.h"
32 #include "components/user_prefs/pref_registry_syncable.h"
33 #include "content/public/browser/browser_thread.h"
34 #include "extensions/common/extension.h"
35 #include "extensions/common/permissions/api_permission.h"
36 #include "extensions/common/permissions/permissions_data.h"
37 #include "grit/generated_resources.h"
38 #include "ui/base/l10n/l10n_util.h"
39 #include "ui/base/text/bytes_formatting.h"
40
41 using base::DictionaryValue;
42 using base::ListValue;
43 using extensions::ExtensionPrefs;
44
45 namespace {
46
47 // Pref key for the list of media gallery permissions.
48 const char kMediaGalleriesPermissions[] = "media_galleries_permissions";
49 // Pref key for Media Gallery ID.
50 const char kMediaGalleryIdKey[] = "id";
51 // Pref key for Media Gallery Permission Value.
52 const char kMediaGalleryHasPermissionKey[] = "has_permission";
53
54 const char kMediaGalleriesDeviceIdKey[] = "deviceId";
55 const char kMediaGalleriesDisplayNameKey[] = "displayName";
56 const char kMediaGalleriesPathKey[] = "path";
57 const char kMediaGalleriesPrefIdKey[] = "prefId";
58 const char kMediaGalleriesTypeKey[] = "type";
59 const char kMediaGalleriesVolumeLabelKey[] = "volumeLabel";
60 const char kMediaGalleriesVendorNameKey[] = "vendorName";
61 const char kMediaGalleriesModelNameKey[] = "modelName";
62 const char kMediaGalleriesSizeKey[] = "totalSize";
63 const char kMediaGalleriesLastAttachTimeKey[] = "lastAttachTime";
64 const char kMediaGalleriesPrefsVersionKey[] = "preferencesVersion";
65
66 const char kMediaGalleriesTypeAutoDetectedValue[] = "autoDetected";
67 const char kMediaGalleriesTypeUserAddedValue[] = "userAdded";
68 const char kMediaGalleriesTypeBlackListedValue[] = "blackListed";
69
70 const char kIPhotoGalleryName[] = "iPhoto";
71 const char kITunesGalleryName[] = "iTunes";
72 const char kPicasaGalleryName[] = "Picasa";
73
NumberExtensionsUsingMediaGalleries(Profile * profile)74 int NumberExtensionsUsingMediaGalleries(Profile* profile) {
75 int count = 0;
76 if (!profile)
77 return count;
78 ExtensionService* extension_service =
79 extensions::ExtensionSystem::Get(profile)->extension_service();
80 if (!extension_service)
81 return count;
82
83 const ExtensionSet* extensions = extension_service->extensions();
84 for (ExtensionSet::const_iterator i = extensions->begin();
85 i != extensions->end(); ++i) {
86 if (extensions::PermissionsData::HasAPIPermission(
87 *i, extensions::APIPermission::kMediaGalleries) ||
88 extensions::PermissionsData::HasAPIPermission(
89 *i, extensions::APIPermission::kMediaGalleriesPrivate)) {
90 count++;
91 }
92 }
93 return count;
94 }
95
GetPrefId(const DictionaryValue & dict,MediaGalleryPrefId * value)96 bool GetPrefId(const DictionaryValue& dict, MediaGalleryPrefId* value) {
97 std::string string_id;
98 if (!dict.GetString(kMediaGalleriesPrefIdKey, &string_id) ||
99 !base::StringToUint64(string_id, value)) {
100 return false;
101 }
102
103 return true;
104 }
105
GetType(const DictionaryValue & dict,MediaGalleryPrefInfo::Type * type)106 bool GetType(const DictionaryValue& dict, MediaGalleryPrefInfo::Type* type) {
107 std::string string_type;
108 if (!dict.GetString(kMediaGalleriesTypeKey, &string_type))
109 return false;
110
111 if (string_type == kMediaGalleriesTypeAutoDetectedValue) {
112 *type = MediaGalleryPrefInfo::kAutoDetected;
113 return true;
114 }
115 if (string_type == kMediaGalleriesTypeUserAddedValue) {
116 *type = MediaGalleryPrefInfo::kUserAdded;
117 return true;
118 }
119 if (string_type == kMediaGalleriesTypeBlackListedValue) {
120 *type = MediaGalleryPrefInfo::kBlackListed;
121 return true;
122 }
123
124 return false;
125 }
126
PopulateGalleryPrefInfoFromDictionary(const DictionaryValue & dict,MediaGalleryPrefInfo * out_gallery_info)127 bool PopulateGalleryPrefInfoFromDictionary(
128 const DictionaryValue& dict, MediaGalleryPrefInfo* out_gallery_info) {
129 MediaGalleryPrefId pref_id;
130 base::string16 display_name;
131 std::string device_id;
132 base::FilePath::StringType path;
133 MediaGalleryPrefInfo::Type type = MediaGalleryPrefInfo::kAutoDetected;
134 base::string16 volume_label;
135 base::string16 vendor_name;
136 base::string16 model_name;
137 double total_size_in_bytes = 0.0;
138 double last_attach_time = 0.0;
139 bool volume_metadata_valid = false;
140 int prefs_version = 0;
141
142 if (!GetPrefId(dict, &pref_id) ||
143 !dict.GetString(kMediaGalleriesDeviceIdKey, &device_id) ||
144 !dict.GetString(kMediaGalleriesPathKey, &path) ||
145 !GetType(dict, &type)) {
146 return false;
147 }
148
149 dict.GetString(kMediaGalleriesDisplayNameKey, &display_name);
150 dict.GetInteger(kMediaGalleriesPrefsVersionKey, &prefs_version);
151
152 if (dict.GetString(kMediaGalleriesVolumeLabelKey, &volume_label) &&
153 dict.GetString(kMediaGalleriesVendorNameKey, &vendor_name) &&
154 dict.GetString(kMediaGalleriesModelNameKey, &model_name) &&
155 dict.GetDouble(kMediaGalleriesSizeKey, &total_size_in_bytes) &&
156 dict.GetDouble(kMediaGalleriesLastAttachTimeKey, &last_attach_time)) {
157 volume_metadata_valid = true;
158 }
159
160 out_gallery_info->pref_id = pref_id;
161 out_gallery_info->display_name = display_name;
162 out_gallery_info->device_id = device_id;
163 out_gallery_info->path = base::FilePath(path);
164 out_gallery_info->type = type;
165 out_gallery_info->volume_label = volume_label;
166 out_gallery_info->vendor_name = vendor_name;
167 out_gallery_info->model_name = model_name;
168 out_gallery_info->total_size_in_bytes = total_size_in_bytes;
169 out_gallery_info->last_attach_time =
170 base::Time::FromInternalValue(last_attach_time);
171 out_gallery_info->volume_metadata_valid = volume_metadata_valid;
172 out_gallery_info->prefs_version = prefs_version;
173
174 return true;
175 }
176
CreateGalleryPrefInfoDictionary(const MediaGalleryPrefInfo & gallery)177 DictionaryValue* CreateGalleryPrefInfoDictionary(
178 const MediaGalleryPrefInfo& gallery) {
179 DictionaryValue* dict = new DictionaryValue();
180 dict->SetString(kMediaGalleriesPrefIdKey,
181 base::Uint64ToString(gallery.pref_id));
182 if (!gallery.volume_metadata_valid)
183 dict->SetString(kMediaGalleriesDisplayNameKey, gallery.display_name);
184 dict->SetString(kMediaGalleriesDeviceIdKey, gallery.device_id);
185 dict->SetString(kMediaGalleriesPathKey, gallery.path.value());
186
187 const char* type = NULL;
188 switch (gallery.type) {
189 case MediaGalleryPrefInfo::kAutoDetected:
190 type = kMediaGalleriesTypeAutoDetectedValue;
191 break;
192 case MediaGalleryPrefInfo::kUserAdded:
193 type = kMediaGalleriesTypeUserAddedValue;
194 break;
195 case MediaGalleryPrefInfo::kBlackListed:
196 type = kMediaGalleriesTypeBlackListedValue;
197 break;
198 default:
199 NOTREACHED();
200 break;
201 }
202 dict->SetString(kMediaGalleriesTypeKey, type);
203
204 if (gallery.volume_metadata_valid) {
205 dict->SetString(kMediaGalleriesVolumeLabelKey, gallery.volume_label);
206 dict->SetString(kMediaGalleriesVendorNameKey, gallery.vendor_name);
207 dict->SetString(kMediaGalleriesModelNameKey, gallery.model_name);
208 dict->SetDouble(kMediaGalleriesSizeKey, gallery.total_size_in_bytes);
209 dict->SetDouble(kMediaGalleriesLastAttachTimeKey,
210 gallery.last_attach_time.ToInternalValue());
211 }
212
213 // Version 0 of the prefs format was that the display_name was always
214 // used to show the user-visible name of the gallery. Version 1 means
215 // that there is an optional display_name, and when it is present, it
216 // overrides the name that would be built from the volume metadata, path,
217 // or whatever other data. So if we see a display_name with version 0, it
218 // means it may be overwritten simply by getting new volume metadata.
219 // A display_name with version 1 should not be overwritten.
220 dict->SetInteger(kMediaGalleriesPrefsVersionKey, gallery.prefs_version);
221
222 return dict;
223 }
224
HasAutoDetectedGalleryPermission(const extensions::Extension & extension)225 bool HasAutoDetectedGalleryPermission(const extensions::Extension& extension) {
226 extensions::MediaGalleriesPermission::CheckParam param(
227 extensions::MediaGalleriesPermission::kAllAutoDetectedPermission);
228 return extensions::PermissionsData::CheckAPIPermissionWithParam(
229 &extension, extensions::APIPermission::kMediaGalleries, ¶m);
230 }
231
232 // Retrieves the MediaGalleryPermission from the given dictionary; DCHECKs on
233 // failure.
GetMediaGalleryPermissionFromDictionary(const DictionaryValue * dict,MediaGalleryPermission * out_permission)234 bool GetMediaGalleryPermissionFromDictionary(
235 const DictionaryValue* dict,
236 MediaGalleryPermission* out_permission) {
237 std::string string_id;
238 if (dict->GetString(kMediaGalleryIdKey, &string_id) &&
239 base::StringToUint64(string_id, &out_permission->pref_id) &&
240 dict->GetBoolean(kMediaGalleryHasPermissionKey,
241 &out_permission->has_permission)) {
242 return true;
243 }
244 NOTREACHED();
245 return false;
246 }
247
GetDisplayNameForDevice(uint64 storage_size_in_bytes,const base::string16 & name)248 base::string16 GetDisplayNameForDevice(uint64 storage_size_in_bytes,
249 const base::string16& name) {
250 DCHECK(!name.empty());
251 return (storage_size_in_bytes == 0) ?
252 name : ui::FormatBytes(storage_size_in_bytes) + ASCIIToUTF16(" ") + name;
253 }
254
255 // For a device with |device_name| and a relative path |sub_folder|, construct
256 // a display name. If |sub_folder| is empty, then just return |device_name|.
GetDisplayNameForSubFolder(const base::string16 & device_name,const base::FilePath & sub_folder)257 base::string16 GetDisplayNameForSubFolder(const base::string16& device_name,
258 const base::FilePath& sub_folder) {
259 if (sub_folder.empty())
260 return device_name;
261 return (sub_folder.BaseName().LossyDisplayName() +
262 ASCIIToUTF16(" - ") +
263 device_name);
264 }
265
GetFullProductName(const base::string16 & vendor_name,const base::string16 & model_name)266 base::string16 GetFullProductName(const base::string16& vendor_name,
267 const base::string16& model_name) {
268 if (vendor_name.empty() && model_name.empty())
269 return base::string16();
270
271 base::string16 product_name;
272 if (vendor_name.empty())
273 product_name = model_name;
274 else if (model_name.empty())
275 product_name = vendor_name;
276 else if (!vendor_name.empty() && !model_name.empty())
277 product_name = vendor_name + UTF8ToUTF16(", ") + model_name;
278
279 return product_name;
280 }
281
282 } // namespace
283
MediaGalleryPrefInfo()284 MediaGalleryPrefInfo::MediaGalleryPrefInfo()
285 : pref_id(kInvalidMediaGalleryPrefId),
286 type(kInvalidType),
287 total_size_in_bytes(0),
288 volume_metadata_valid(false),
289 prefs_version(0) {
290 }
291
~MediaGalleryPrefInfo()292 MediaGalleryPrefInfo::~MediaGalleryPrefInfo() {}
293
AbsolutePath() const294 base::FilePath MediaGalleryPrefInfo::AbsolutePath() const {
295 base::FilePath base_path = MediaStorageUtil::FindDevicePathById(device_id);
296 DCHECK(!path.IsAbsolute());
297 return base_path.empty() ? base_path : base_path.Append(path);
298 }
299
GetGalleryDisplayName() const300 base::string16 MediaGalleryPrefInfo::GetGalleryDisplayName() const {
301 if (!StorageInfo::IsRemovableDevice(device_id)) {
302 // For fixed storage, the default name is the fully qualified directory
303 // name, or in the case of a root directory, the root directory name.
304 // Exception: ChromeOS -- the full pathname isn't visible there, so only
305 // the directory name is used.
306 base::FilePath path = AbsolutePath();
307 if (!display_name.empty())
308 return display_name;
309
310 #if defined(OS_CHROMEOS)
311 // See chrome/browser/chromeos/fileapi/file_system_backend.cc
312 base::FilePath home_path;
313 if (PathService::Get(base::DIR_HOME, &home_path)) {
314 home_path = home_path.AppendASCII("Downloads");
315 base::FilePath relative;
316 if (home_path.AppendRelativePath(path, &relative))
317 return relative.LossyDisplayName();
318 }
319 return path.BaseName().LossyDisplayName();
320 #else
321 return path.LossyDisplayName();
322 #endif
323 }
324
325 base::string16 name = display_name;
326 if (name.empty())
327 name = volume_label;
328 if (name.empty())
329 name = GetFullProductName(vendor_name, model_name);
330 if (name.empty())
331 name = l10n_util::GetStringUTF16(IDS_MEDIA_GALLERIES_UNLABELED_DEVICE);
332
333 name = GetDisplayNameForDevice(total_size_in_bytes, name);
334
335 if (!path.empty())
336 name = GetDisplayNameForSubFolder(name, path);
337
338 return name;
339 }
340
GetGalleryTooltip() const341 base::string16 MediaGalleryPrefInfo::GetGalleryTooltip() const {
342 return AbsolutePath().LossyDisplayName();
343 }
344
GetGalleryAdditionalDetails() const345 base::string16 MediaGalleryPrefInfo::GetGalleryAdditionalDetails() const {
346 base::string16 attached;
347 if (StorageInfo::IsRemovableDevice(device_id)) {
348 if (MediaStorageUtil::IsRemovableStorageAttached(device_id)) {
349 attached = l10n_util::GetStringUTF16(
350 IDS_MEDIA_GALLERIES_DIALOG_DEVICE_ATTACHED);
351 } else if (!last_attach_time.is_null()) {
352 attached = l10n_util::GetStringFUTF16(
353 IDS_MEDIA_GALLERIES_LAST_ATTACHED,
354 base::TimeFormatShortDateNumeric(last_attach_time));
355 } else {
356 attached = l10n_util::GetStringUTF16(
357 IDS_MEDIA_GALLERIES_DIALOG_DEVICE_NOT_ATTACHED);
358 }
359 }
360
361 return attached;
362 }
363
IsGalleryAvailable() const364 bool MediaGalleryPrefInfo::IsGalleryAvailable() const {
365 return !StorageInfo::IsRemovableDevice(device_id) ||
366 MediaStorageUtil::IsRemovableStorageAttached(device_id);
367 }
368
~GalleryChangeObserver()369 MediaGalleriesPreferences::GalleryChangeObserver::~GalleryChangeObserver() {}
370
MediaGalleriesPreferences(Profile * profile)371 MediaGalleriesPreferences::MediaGalleriesPreferences(Profile* profile)
372 : initialized_(false),
373 pre_initialization_callbacks_waiting_(0),
374 profile_(profile),
375 extension_prefs_for_testing_(NULL),
376 weak_factory_(this) {
377 }
378
~MediaGalleriesPreferences()379 MediaGalleriesPreferences::~MediaGalleriesPreferences() {
380 if (StorageMonitor::GetInstance())
381 StorageMonitor::GetInstance()->RemoveObserver(this);
382 }
383
EnsureInitialized(base::Closure callback)384 void MediaGalleriesPreferences::EnsureInitialized(base::Closure callback) {
385 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
386
387 if (IsInitialized()) {
388 if (!callback.is_null())
389 callback.Run();
390 return;
391 }
392
393 on_initialize_callbacks_.push_back(callback);
394 if (on_initialize_callbacks_.size() > 1)
395 return;
396
397 // This counter must match the number of async methods dispatched below.
398 // It cannot be incremented inline with each callback, as some may return
399 // synchronously, decrement the counter to 0, and prematurely trigger
400 // FinishInitialization.
401 pre_initialization_callbacks_waiting_ = 3;
402
403 // Check whether we should be initializing -- are there any extensions that
404 // are using media galleries?
405 media_galleries::UsageCount(media_galleries::PREFS_INITIALIZED);
406 if (NumberExtensionsUsingMediaGalleries(profile_) == 0) {
407 media_galleries::UsageCount(media_galleries::PREFS_INITIALIZED_ERROR);
408 }
409
410 // We determine the freshness of the profile here, before any of the finders
411 // return and add media galleries to it.
412 StorageMonitor::GetInstance()->EnsureInitialized(
413 base::Bind(&MediaGalleriesPreferences::OnStorageMonitorInit,
414 weak_factory_.GetWeakPtr(),
415 !APIHasBeenUsed(profile_) /* add_default_galleries */));
416
417 // Look for optional default galleries every time.
418 iapps::FindITunesLibrary(
419 base::Bind(&MediaGalleriesPreferences::OnFinderDeviceID,
420 weak_factory_.GetWeakPtr()));
421
422 picasa::FindPicasaDatabase(
423 base::Bind(&MediaGalleriesPreferences::OnFinderDeviceID,
424 weak_factory_.GetWeakPtr()));
425
426 #if 0
427 iapps::FindIPhotoLibrary(
428 base::Bind(&MediaGalleriesPreferences::OnFinderDeviceID,
429 weak_factory_.GetWeakPtr()));
430 #endif
431 }
432
IsInitialized() const433 bool MediaGalleriesPreferences::IsInitialized() const { return initialized_; }
434
profile()435 Profile* MediaGalleriesPreferences::profile() { return profile_; }
436
OnInitializationCallbackReturned()437 void MediaGalleriesPreferences::OnInitializationCallbackReturned() {
438 DCHECK(!IsInitialized());
439 DCHECK(pre_initialization_callbacks_waiting_ > 0);
440 if (--pre_initialization_callbacks_waiting_ == 0)
441 FinishInitialization();
442 }
443
FinishInitialization()444 void MediaGalleriesPreferences::FinishInitialization() {
445 DCHECK(!IsInitialized());
446
447 initialized_ = true;
448
449 StorageMonitor* monitor = StorageMonitor::GetInstance();
450 DCHECK(monitor->IsInitialized());
451
452 InitFromPrefs();
453
454 StorageMonitor::GetInstance()->AddObserver(this);
455
456 std::vector<StorageInfo> existing_devices =
457 monitor->GetAllAvailableStorages();
458 for (size_t i = 0; i < existing_devices.size(); i++) {
459 if (!(StorageInfo::IsMediaDevice(existing_devices[i].device_id()) &&
460 StorageInfo::IsRemovableDevice(existing_devices[i].device_id())))
461 continue;
462 AddGallery(existing_devices[i].device_id(),
463 base::FilePath(),
464 false,
465 existing_devices[i].storage_label(),
466 existing_devices[i].vendor_name(),
467 existing_devices[i].model_name(),
468 existing_devices[i].total_size_in_bytes(),
469 base::Time::Now());
470 }
471
472 for (std::vector<base::Closure>::iterator iter =
473 on_initialize_callbacks_.begin();
474 iter != on_initialize_callbacks_.end();
475 ++iter) {
476 iter->Run();
477 }
478 on_initialize_callbacks_.clear();
479 }
480
AddDefaultGalleries()481 void MediaGalleriesPreferences::AddDefaultGalleries() {
482 const int kDirectoryKeys[] = {
483 chrome::DIR_USER_MUSIC,
484 chrome::DIR_USER_PICTURES,
485 chrome::DIR_USER_VIDEOS,
486 };
487
488 for (size_t i = 0; i < arraysize(kDirectoryKeys); ++i) {
489 base::FilePath path;
490 if (!PathService::Get(kDirectoryKeys[i], &path))
491 continue;
492
493 base::FilePath relative_path;
494 StorageInfo info;
495 if (MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path)) {
496 AddGalleryInternal(info.device_id(), info.name(), relative_path, false,
497 info.storage_label(), info.vendor_name(),
498 info.model_name(), info.total_size_in_bytes(),
499 base::Time(), true, 2);
500 }
501 }
502 }
503
UpdateDeviceIDForSingletonType(const std::string & device_id)504 bool MediaGalleriesPreferences::UpdateDeviceIDForSingletonType(
505 const std::string& device_id) {
506 StorageInfo::Type singleton_type;
507 if (!StorageInfo::CrackDeviceId(device_id, &singleton_type, NULL))
508 return false;
509
510 PrefService* prefs = profile_->GetPrefs();
511 scoped_ptr<ListPrefUpdate> update(new ListPrefUpdate(
512 prefs, prefs::kMediaGalleriesRememberedGalleries));
513 ListValue* list = update->Get();
514 for (ListValue::iterator iter = list->begin(); iter != list->end(); ++iter) {
515 // All of these calls should succeed, but preferences file can be corrupt.
516 DictionaryValue* dict;
517 if (!(*iter)->GetAsDictionary(&dict))
518 continue;
519 std::string this_device_id;
520 if (!dict->GetString(kMediaGalleriesDeviceIdKey, &this_device_id))
521 continue;
522 if (this_device_id == device_id)
523 return true; // No update is necessary.
524 StorageInfo::Type device_type;
525 if (!StorageInfo::CrackDeviceId(this_device_id, &device_type, NULL))
526 continue;
527
528 if (device_type == singleton_type) {
529 dict->SetString(kMediaGalleriesDeviceIdKey, device_id);
530 update.reset(); // commits the update.
531 InitFromPrefs();
532 MediaGalleryPrefId pref_id;
533 if (GetPrefId(*dict, &pref_id)) {
534 FOR_EACH_OBSERVER(GalleryChangeObserver,
535 gallery_change_observers_,
536 OnGalleryInfoUpdated(this, pref_id));
537 }
538 return true;
539 }
540 }
541 return false;
542 }
543
OnStorageMonitorInit(bool add_default_galleries)544 void MediaGalleriesPreferences::OnStorageMonitorInit(
545 bool add_default_galleries) {
546 if (add_default_galleries)
547 AddDefaultGalleries();
548 OnInitializationCallbackReturned();
549 }
550
OnFinderDeviceID(const std::string & device_id)551 void MediaGalleriesPreferences::OnFinderDeviceID(const std::string& device_id) {
552 if (!device_id.empty() && !UpdateDeviceIDForSingletonType(device_id)) {
553 std::string gallery_name;
554 if (StorageInfo::IsIPhotoDevice(device_id))
555 gallery_name = kIPhotoGalleryName;
556 else if (StorageInfo::IsITunesDevice(device_id))
557 gallery_name = kITunesGalleryName;
558 else if (StorageInfo::IsPicasaDevice(device_id))
559 gallery_name = kPicasaGalleryName;
560 else
561 NOTREACHED();
562
563 AddGalleryInternal(device_id, ASCIIToUTF16(gallery_name),
564 base::FilePath(), false /*not user added*/,
565 base::string16(), base::string16(), base::string16(), 0,
566 base::Time(), false, 2);
567 }
568
569 OnInitializationCallbackReturned();
570 }
571
InitFromPrefs()572 void MediaGalleriesPreferences::InitFromPrefs() {
573 known_galleries_.clear();
574 device_map_.clear();
575
576 PrefService* prefs = profile_->GetPrefs();
577 const ListValue* list = prefs->GetList(
578 prefs::kMediaGalleriesRememberedGalleries);
579 if (list) {
580 for (ListValue::const_iterator it = list->begin();
581 it != list->end(); ++it) {
582 const DictionaryValue* dict = NULL;
583 if (!(*it)->GetAsDictionary(&dict))
584 continue;
585
586 MediaGalleryPrefInfo gallery_info;
587 if (!PopulateGalleryPrefInfoFromDictionary(*dict, &gallery_info))
588 continue;
589
590 known_galleries_[gallery_info.pref_id] = gallery_info;
591 device_map_[gallery_info.device_id].insert(gallery_info.pref_id);
592 }
593 }
594 }
595
AddGalleryChangeObserver(GalleryChangeObserver * observer)596 void MediaGalleriesPreferences::AddGalleryChangeObserver(
597 GalleryChangeObserver* observer) {
598 DCHECK(IsInitialized());
599 gallery_change_observers_.AddObserver(observer);
600 }
601
RemoveGalleryChangeObserver(GalleryChangeObserver * observer)602 void MediaGalleriesPreferences::RemoveGalleryChangeObserver(
603 GalleryChangeObserver* observer) {
604 DCHECK(IsInitialized());
605 gallery_change_observers_.RemoveObserver(observer);
606 }
607
OnRemovableStorageAttached(const StorageInfo & info)608 void MediaGalleriesPreferences::OnRemovableStorageAttached(
609 const StorageInfo& info) {
610 DCHECK(IsInitialized());
611 if (!StorageInfo::IsMediaDevice(info.device_id()))
612 return;
613
614 AddGallery(info.device_id(), base::FilePath(),
615 false /*not user added*/,
616 info.storage_label(),
617 info.vendor_name(),
618 info.model_name(),
619 info.total_size_in_bytes(),
620 base::Time::Now());
621 }
622
LookUpGalleryByPath(const base::FilePath & path,MediaGalleryPrefInfo * gallery_info) const623 bool MediaGalleriesPreferences::LookUpGalleryByPath(
624 const base::FilePath& path,
625 MediaGalleryPrefInfo* gallery_info) const {
626 DCHECK(IsInitialized());
627 StorageInfo info;
628 base::FilePath relative_path;
629 if (!MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path)) {
630 if (gallery_info)
631 *gallery_info = MediaGalleryPrefInfo();
632 return false;
633 }
634
635 relative_path = relative_path.NormalizePathSeparators();
636 MediaGalleryPrefIdSet galleries_on_device =
637 LookUpGalleriesByDeviceId(info.device_id());
638 for (MediaGalleryPrefIdSet::const_iterator it = galleries_on_device.begin();
639 it != galleries_on_device.end();
640 ++it) {
641 const MediaGalleryPrefInfo& gallery = known_galleries_.find(*it)->second;
642 if (gallery.path != relative_path)
643 continue;
644
645 if (gallery_info)
646 *gallery_info = gallery;
647 return true;
648 }
649
650 // This method is called by controller::FilesSelected when the user
651 // adds a new gallery. Control reaches here when the selected gallery is
652 // on a volume we know about, but have no gallery already for. Returns
653 // hypothetical data to the caller about what the prefs will look like
654 // if the gallery is added.
655 // TODO(gbillock): split this out into another function so it doesn't
656 // conflate LookUp.
657 if (gallery_info) {
658 gallery_info->pref_id = kInvalidMediaGalleryPrefId;
659 gallery_info->device_id = info.device_id();
660 gallery_info->path = relative_path;
661 gallery_info->type = MediaGalleryPrefInfo::kUserAdded;
662 gallery_info->volume_label = info.storage_label();
663 gallery_info->vendor_name = info.vendor_name();
664 gallery_info->model_name = info.model_name();
665 gallery_info->total_size_in_bytes = info.total_size_in_bytes();
666 gallery_info->last_attach_time = base::Time::Now();
667 gallery_info->volume_metadata_valid = true;
668 gallery_info->prefs_version = 2;
669 }
670 return false;
671 }
672
LookUpGalleriesByDeviceId(const std::string & device_id) const673 MediaGalleryPrefIdSet MediaGalleriesPreferences::LookUpGalleriesByDeviceId(
674 const std::string& device_id) const {
675 DeviceIdPrefIdsMap::const_iterator found = device_map_.find(device_id);
676 if (found == device_map_.end())
677 return MediaGalleryPrefIdSet();
678 return found->second;
679 }
680
LookUpGalleryPathForExtension(MediaGalleryPrefId gallery_id,const extensions::Extension * extension,bool include_unpermitted_galleries)681 base::FilePath MediaGalleriesPreferences::LookUpGalleryPathForExtension(
682 MediaGalleryPrefId gallery_id,
683 const extensions::Extension* extension,
684 bool include_unpermitted_galleries) {
685 DCHECK(IsInitialized());
686 DCHECK(extension);
687 if (!include_unpermitted_galleries &&
688 !ContainsKey(GalleriesForExtension(*extension), gallery_id))
689 return base::FilePath();
690
691 MediaGalleriesPrefInfoMap::const_iterator it =
692 known_galleries_.find(gallery_id);
693 if (it == known_galleries_.end())
694 return base::FilePath();
695 return MediaStorageUtil::FindDevicePathById(it->second.device_id);
696 }
697
AddGallery(const std::string & device_id,const base::FilePath & relative_path,bool user_added,const base::string16 & volume_label,const base::string16 & vendor_name,const base::string16 & model_name,uint64 total_size_in_bytes,base::Time last_attach_time)698 MediaGalleryPrefId MediaGalleriesPreferences::AddGallery(
699 const std::string& device_id,
700 const base::FilePath& relative_path, bool user_added,
701 const base::string16& volume_label, const base::string16& vendor_name,
702 const base::string16& model_name, uint64 total_size_in_bytes,
703 base::Time last_attach_time) {
704 DCHECK(IsInitialized());
705 return AddGalleryInternal(device_id, base::string16(), relative_path,
706 user_added, volume_label, vendor_name, model_name,
707 total_size_in_bytes, last_attach_time, true, 2);
708 }
709
AddGalleryInternal(const std::string & device_id,const base::string16 & display_name,const base::FilePath & relative_path,bool user_added,const base::string16 & volume_label,const base::string16 & vendor_name,const base::string16 & model_name,uint64 total_size_in_bytes,base::Time last_attach_time,bool volume_metadata_valid,int prefs_version)710 MediaGalleryPrefId MediaGalleriesPreferences::AddGalleryInternal(
711 const std::string& device_id, const base::string16& display_name,
712 const base::FilePath& relative_path, bool user_added,
713 const base::string16& volume_label, const base::string16& vendor_name,
714 const base::string16& model_name, uint64 total_size_in_bytes,
715 base::Time last_attach_time,
716 bool volume_metadata_valid,
717 int prefs_version) {
718 base::FilePath normalized_relative_path =
719 relative_path.NormalizePathSeparators();
720 MediaGalleryPrefIdSet galleries_on_device =
721 LookUpGalleriesByDeviceId(device_id);
722 for (MediaGalleryPrefIdSet::const_iterator pref_id_it =
723 galleries_on_device.begin();
724 pref_id_it != galleries_on_device.end();
725 ++pref_id_it) {
726 const MediaGalleryPrefInfo& existing =
727 known_galleries_.find(*pref_id_it)->second;
728 if (existing.path != normalized_relative_path)
729 continue;
730
731 bool update_gallery_type =
732 user_added && (existing.type == MediaGalleryPrefInfo::kBlackListed);
733 // Status quo: In M27 and M28, galleries added manually use version 0,
734 // and galleries added automatically (including default galleries) use
735 // version 1. The name override is used by default galleries as well
736 // as all device attach events.
737 // We want to upgrade the name if the existing version is < 2. Leave it
738 // alone if the existing display name is set with version == 2 and the
739 // proposed new name is empty.
740 bool update_gallery_name = existing.display_name != display_name;
741 if (existing.prefs_version == 2 && !existing.display_name.empty() &&
742 display_name.empty()) {
743 update_gallery_name = false;
744 }
745 bool update_gallery_metadata = volume_metadata_valid &&
746 ((existing.volume_label != volume_label) ||
747 (existing.vendor_name != vendor_name) ||
748 (existing.model_name != model_name) ||
749 (existing.total_size_in_bytes != total_size_in_bytes) ||
750 (existing.last_attach_time != last_attach_time));
751
752 if (!update_gallery_name && !update_gallery_type &&
753 !update_gallery_metadata)
754 return *pref_id_it;
755
756 PrefService* prefs = profile_->GetPrefs();
757 scoped_ptr<ListPrefUpdate> update(
758 new ListPrefUpdate(prefs, prefs::kMediaGalleriesRememberedGalleries));
759 ListValue* list = update->Get();
760
761 for (ListValue::const_iterator list_iter = list->begin();
762 list_iter != list->end();
763 ++list_iter) {
764 DictionaryValue* dict;
765 MediaGalleryPrefId iter_id;
766 if ((*list_iter)->GetAsDictionary(&dict) &&
767 GetPrefId(*dict, &iter_id) &&
768 *pref_id_it == iter_id) {
769 if (update_gallery_type) {
770 dict->SetString(kMediaGalleriesTypeKey,
771 kMediaGalleriesTypeAutoDetectedValue);
772 }
773 if (update_gallery_name)
774 dict->SetString(kMediaGalleriesDisplayNameKey, display_name);
775 if (update_gallery_metadata) {
776 dict->SetString(kMediaGalleriesVolumeLabelKey, volume_label);
777 dict->SetString(kMediaGalleriesVendorNameKey, vendor_name);
778 dict->SetString(kMediaGalleriesModelNameKey, model_name);
779 dict->SetDouble(kMediaGalleriesSizeKey, total_size_in_bytes);
780 dict->SetDouble(kMediaGalleriesLastAttachTimeKey,
781 last_attach_time.ToInternalValue());
782 }
783 dict->SetInteger(kMediaGalleriesPrefsVersionKey, prefs_version);
784 break;
785 }
786 }
787
788 // Commits the prefs update.
789 update.reset();
790
791 if (update_gallery_name || update_gallery_metadata ||
792 update_gallery_type) {
793 InitFromPrefs();
794 FOR_EACH_OBSERVER(GalleryChangeObserver,
795 gallery_change_observers_,
796 OnGalleryInfoUpdated(this, *pref_id_it));
797 }
798 return *pref_id_it;
799 }
800
801 PrefService* prefs = profile_->GetPrefs();
802
803 MediaGalleryPrefInfo gallery_info;
804 gallery_info.pref_id = prefs->GetUint64(prefs::kMediaGalleriesUniqueId);
805 prefs->SetUint64(prefs::kMediaGalleriesUniqueId, gallery_info.pref_id + 1);
806 gallery_info.display_name = display_name;
807 gallery_info.device_id = device_id;
808 gallery_info.path = normalized_relative_path;
809 gallery_info.type = MediaGalleryPrefInfo::kAutoDetected;
810 if (user_added)
811 gallery_info.type = MediaGalleryPrefInfo::kUserAdded;
812 if (volume_metadata_valid) {
813 gallery_info.volume_label = volume_label;
814 gallery_info.vendor_name = vendor_name;
815 gallery_info.model_name = model_name;
816 gallery_info.total_size_in_bytes = total_size_in_bytes;
817 gallery_info.last_attach_time = last_attach_time;
818 }
819 gallery_info.volume_metadata_valid = volume_metadata_valid;
820 gallery_info.prefs_version = prefs_version;
821
822 {
823 ListPrefUpdate update(prefs, prefs::kMediaGalleriesRememberedGalleries);
824 ListValue* list = update.Get();
825 list->Append(CreateGalleryPrefInfoDictionary(gallery_info));
826 }
827 InitFromPrefs();
828 FOR_EACH_OBSERVER(GalleryChangeObserver,
829 gallery_change_observers_,
830 OnGalleryAdded(this, gallery_info.pref_id));
831
832 return gallery_info.pref_id;
833 }
834
AddGalleryByPath(const base::FilePath & path)835 MediaGalleryPrefId MediaGalleriesPreferences::AddGalleryByPath(
836 const base::FilePath& path) {
837 DCHECK(IsInitialized());
838 MediaGalleryPrefInfo gallery_info;
839 if (LookUpGalleryByPath(path, &gallery_info) &&
840 gallery_info.type != MediaGalleryPrefInfo::kBlackListed) {
841 return gallery_info.pref_id;
842 }
843 return AddGalleryInternal(gallery_info.device_id,
844 gallery_info.display_name,
845 gallery_info.path,
846 true /*user added*/,
847 gallery_info.volume_label,
848 gallery_info.vendor_name,
849 gallery_info.model_name,
850 gallery_info.total_size_in_bytes,
851 gallery_info.last_attach_time,
852 gallery_info.volume_metadata_valid,
853 gallery_info.prefs_version);
854 }
855
ForgetGalleryById(MediaGalleryPrefId pref_id)856 void MediaGalleriesPreferences::ForgetGalleryById(MediaGalleryPrefId pref_id) {
857 DCHECK(IsInitialized());
858 PrefService* prefs = profile_->GetPrefs();
859 scoped_ptr<ListPrefUpdate> update(new ListPrefUpdate(
860 prefs, prefs::kMediaGalleriesRememberedGalleries));
861 ListValue* list = update->Get();
862
863 if (!ContainsKey(known_galleries_, pref_id))
864 return;
865
866 for (ListValue::iterator iter = list->begin(); iter != list->end(); ++iter) {
867 DictionaryValue* dict;
868 MediaGalleryPrefId iter_id;
869 if ((*iter)->GetAsDictionary(&dict) && GetPrefId(*dict, &iter_id) &&
870 pref_id == iter_id) {
871 RemoveGalleryPermissionsFromPrefs(pref_id);
872 MediaGalleryPrefInfo::Type type;
873 if (GetType(*dict, &type) &&
874 type == MediaGalleryPrefInfo::kAutoDetected) {
875 dict->SetString(kMediaGalleriesTypeKey,
876 kMediaGalleriesTypeBlackListedValue);
877 } else {
878 list->Erase(iter, NULL);
879 }
880 update.reset(NULL); // commits the update.
881
882 InitFromPrefs();
883 FOR_EACH_OBSERVER(GalleryChangeObserver,
884 gallery_change_observers_,
885 OnGalleryRemoved(this, pref_id));
886 return;
887 }
888 }
889 }
890
GalleriesForExtension(const extensions::Extension & extension) const891 MediaGalleryPrefIdSet MediaGalleriesPreferences::GalleriesForExtension(
892 const extensions::Extension& extension) const {
893 DCHECK(IsInitialized());
894 MediaGalleryPrefIdSet result;
895
896 if (HasAutoDetectedGalleryPermission(extension)) {
897 for (MediaGalleriesPrefInfoMap::const_iterator it =
898 known_galleries_.begin(); it != known_galleries_.end(); ++it) {
899 if (it->second.type == MediaGalleryPrefInfo::kAutoDetected)
900 result.insert(it->second.pref_id);
901 }
902 }
903
904 std::vector<MediaGalleryPermission> stored_permissions =
905 GetGalleryPermissionsFromPrefs(extension.id());
906 for (std::vector<MediaGalleryPermission>::const_iterator it =
907 stored_permissions.begin(); it != stored_permissions.end(); ++it) {
908 if (!it->has_permission) {
909 result.erase(it->pref_id);
910 } else {
911 MediaGalleriesPrefInfoMap::const_iterator gallery =
912 known_galleries_.find(it->pref_id);
913 DCHECK(gallery != known_galleries_.end());
914 if (gallery->second.type != MediaGalleryPrefInfo::kBlackListed) {
915 result.insert(it->pref_id);
916 } else {
917 NOTREACHED() << gallery->second.device_id;
918 }
919 }
920 }
921 return result;
922 }
923
SetGalleryPermissionForExtension(const extensions::Extension & extension,MediaGalleryPrefId pref_id,bool has_permission)924 bool MediaGalleriesPreferences::SetGalleryPermissionForExtension(
925 const extensions::Extension& extension,
926 MediaGalleryPrefId pref_id,
927 bool has_permission) {
928 DCHECK(IsInitialized());
929 // The gallery may not exist anymore if the user opened a second config
930 // surface concurrently and removed it. Drop the permission update if so.
931 MediaGalleriesPrefInfoMap::const_iterator gallery_info =
932 known_galleries_.find(pref_id);
933 if (gallery_info == known_galleries_.end())
934 return false;
935
936 bool default_permission = false;
937 if (gallery_info->second.type == MediaGalleryPrefInfo::kAutoDetected)
938 default_permission = HasAutoDetectedGalleryPermission(extension);
939 // When the permission matches the default, we don't need to remember it.
940 if (has_permission == default_permission) {
941 if (!UnsetGalleryPermissionInPrefs(extension.id(), pref_id))
942 // If permission wasn't set, assume nothing has changed.
943 return false;
944 } else {
945 if (!SetGalleryPermissionInPrefs(extension.id(), pref_id, has_permission))
946 return false;
947 }
948 if (has_permission)
949 FOR_EACH_OBSERVER(GalleryChangeObserver,
950 gallery_change_observers_,
951 OnPermissionAdded(this, extension.id(), pref_id));
952 else
953 FOR_EACH_OBSERVER(GalleryChangeObserver,
954 gallery_change_observers_,
955 OnPermissionRemoved(this, extension.id(), pref_id));
956 return true;
957 }
958
known_galleries() const959 const MediaGalleriesPrefInfoMap& MediaGalleriesPreferences::known_galleries()
960 const {
961 DCHECK(IsInitialized());
962 return known_galleries_;
963 }
964
Shutdown()965 void MediaGalleriesPreferences::Shutdown() {
966 weak_factory_.InvalidateWeakPtrs();
967 profile_ = NULL;
968 }
969
970 // static
APIHasBeenUsed(Profile * profile)971 bool MediaGalleriesPreferences::APIHasBeenUsed(Profile* profile) {
972 MediaGalleryPrefId current_id =
973 profile->GetPrefs()->GetUint64(prefs::kMediaGalleriesUniqueId);
974 return current_id != kInvalidMediaGalleryPrefId + 1;
975 }
976
977 // static
RegisterProfilePrefs(user_prefs::PrefRegistrySyncable * registry)978 void MediaGalleriesPreferences::RegisterProfilePrefs(
979 user_prefs::PrefRegistrySyncable* registry) {
980 registry->RegisterListPref(prefs::kMediaGalleriesRememberedGalleries,
981 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
982 registry->RegisterUint64Pref(
983 prefs::kMediaGalleriesUniqueId,
984 kInvalidMediaGalleryPrefId + 1,
985 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
986 }
987
SetGalleryPermissionInPrefs(const std::string & extension_id,MediaGalleryPrefId gallery_id,bool has_access)988 bool MediaGalleriesPreferences::SetGalleryPermissionInPrefs(
989 const std::string& extension_id,
990 MediaGalleryPrefId gallery_id,
991 bool has_access) {
992 DCHECK(IsInitialized());
993 ExtensionPrefs::ScopedListUpdate update(GetExtensionPrefs(),
994 extension_id,
995 kMediaGalleriesPermissions);
996 ListValue* permissions = update.Get();
997 if (!permissions) {
998 permissions = update.Create();
999 } else {
1000 // If the gallery is already in the list, update the permission...
1001 for (ListValue::iterator iter = permissions->begin();
1002 iter != permissions->end(); ++iter) {
1003 DictionaryValue* dict = NULL;
1004 if (!(*iter)->GetAsDictionary(&dict))
1005 continue;
1006 MediaGalleryPermission perm;
1007 if (!GetMediaGalleryPermissionFromDictionary(dict, &perm))
1008 continue;
1009 if (perm.pref_id == gallery_id) {
1010 if (has_access != perm.has_permission) {
1011 dict->SetBoolean(kMediaGalleryHasPermissionKey, has_access);
1012 return true;
1013 } else {
1014 return false;
1015 }
1016 }
1017 }
1018 }
1019 // ...Otherwise, add a new entry for the gallery.
1020 DictionaryValue* dict = new DictionaryValue;
1021 dict->SetString(kMediaGalleryIdKey, base::Uint64ToString(gallery_id));
1022 dict->SetBoolean(kMediaGalleryHasPermissionKey, has_access);
1023 permissions->Append(dict);
1024 return true;
1025 }
1026
UnsetGalleryPermissionInPrefs(const std::string & extension_id,MediaGalleryPrefId gallery_id)1027 bool MediaGalleriesPreferences::UnsetGalleryPermissionInPrefs(
1028 const std::string& extension_id,
1029 MediaGalleryPrefId gallery_id) {
1030 DCHECK(IsInitialized());
1031 ExtensionPrefs::ScopedListUpdate update(GetExtensionPrefs(),
1032 extension_id,
1033 kMediaGalleriesPermissions);
1034 ListValue* permissions = update.Get();
1035 if (!permissions)
1036 return false;
1037
1038 for (ListValue::iterator iter = permissions->begin();
1039 iter != permissions->end(); ++iter) {
1040 const DictionaryValue* dict = NULL;
1041 if (!(*iter)->GetAsDictionary(&dict))
1042 continue;
1043 MediaGalleryPermission perm;
1044 if (!GetMediaGalleryPermissionFromDictionary(dict, &perm))
1045 continue;
1046 if (perm.pref_id == gallery_id) {
1047 permissions->Erase(iter, NULL);
1048 return true;
1049 }
1050 }
1051 return false;
1052 }
1053
1054 std::vector<MediaGalleryPermission>
GetGalleryPermissionsFromPrefs(const std::string & extension_id) const1055 MediaGalleriesPreferences::GetGalleryPermissionsFromPrefs(
1056 const std::string& extension_id) const {
1057 DCHECK(IsInitialized());
1058 std::vector<MediaGalleryPermission> result;
1059 const ListValue* permissions;
1060 if (!GetExtensionPrefs()->ReadPrefAsList(extension_id,
1061 kMediaGalleriesPermissions,
1062 &permissions)) {
1063 return result;
1064 }
1065
1066 for (ListValue::const_iterator iter = permissions->begin();
1067 iter != permissions->end(); ++iter) {
1068 DictionaryValue* dict = NULL;
1069 if (!(*iter)->GetAsDictionary(&dict))
1070 continue;
1071 MediaGalleryPermission perm;
1072 if (!GetMediaGalleryPermissionFromDictionary(dict, &perm))
1073 continue;
1074 result.push_back(perm);
1075 }
1076
1077 return result;
1078 }
1079
RemoveGalleryPermissionsFromPrefs(MediaGalleryPrefId gallery_id)1080 void MediaGalleriesPreferences::RemoveGalleryPermissionsFromPrefs(
1081 MediaGalleryPrefId gallery_id) {
1082 DCHECK(IsInitialized());
1083 ExtensionPrefs* prefs = GetExtensionPrefs();
1084 const DictionaryValue* extensions =
1085 prefs->pref_service()->GetDictionary(prefs::kExtensionsPref);
1086 if (!extensions)
1087 return;
1088
1089 for (DictionaryValue::Iterator iter(*extensions); !iter.IsAtEnd();
1090 iter.Advance()) {
1091 if (!extensions::Extension::IdIsValid(iter.key())) {
1092 NOTREACHED();
1093 continue;
1094 }
1095 UnsetGalleryPermissionInPrefs(iter.key(), gallery_id);
1096 }
1097 }
1098
GetExtensionPrefs() const1099 ExtensionPrefs* MediaGalleriesPreferences::GetExtensionPrefs() const {
1100 DCHECK(IsInitialized());
1101 if (extension_prefs_for_testing_)
1102 return extension_prefs_for_testing_;
1103 return extensions::ExtensionPrefs::Get(profile_);
1104 }
1105
SetExtensionPrefsForTesting(extensions::ExtensionPrefs * extension_prefs)1106 void MediaGalleriesPreferences::SetExtensionPrefsForTesting(
1107 extensions::ExtensionPrefs* extension_prefs) {
1108 DCHECK(IsInitialized());
1109 extension_prefs_for_testing_ = extension_prefs;
1110 }
1111