src/chrome/browser/media_galleries/media_file_system_registry.cc

   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_file_system_registry.h"
   6
   7 #include <set>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/callback.h"
  12 #include "base/files/file_path.h"
  13 #include "base/prefs/pref_service.h"
  14 #include "base/stl_util.h"
  15 #include "chrome/browser/extensions/extension_service.h"
  16 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
  17 #include "chrome/browser/media_galleries/fileapi/mtp_device_map_service.h"
  18 #include "chrome/browser/media_galleries/imported_media_gallery_registry.h"
  19 #include "chrome/browser/media_galleries/media_file_system_context.h"
  20 #include "chrome/browser/media_galleries/media_galleries_dialog_controller.h"
  21 #include "chrome/browser/media_galleries/media_galleries_histograms.h"
  22 #include "chrome/browser/media_galleries/media_galleries_preferences_factory.h"
  23 #include "chrome/browser/media_galleries/media_scan_manager.h"
  24 #include "chrome/browser/profiles/profile.h"
  25 #include "chrome/common/chrome_paths.h"
  26 #include "chrome/common/extensions/extension_constants.h"
  27 #include "chrome/common/pref_names.h"
  28 #include "components/storage_monitor/media_storage_util.h"
  29 #include "components/storage_monitor/storage_monitor.h"
  30 #include "content/public/browser/browser_thread.h"
  31 #include "content/public/browser/navigation_details.h"
  32 #include "content/public/browser/render_process_host.h"
  33 #include "content/public/browser/render_process_host_observer.h"
  34 #include "content/public/browser/render_view_host.h"
  35 #include "content/public/browser/web_contents.h"
  36 #include "content/public/browser/web_contents_observer.h"
  37 #include "extensions/browser/extension_system.h"
  38 #include "extensions/common/extension.h"
  39 #include "extensions/common/extension_set.h"
  40 #include "webkit/browser/fileapi/external_mount_points.h"
  41 #include "webkit/common/fileapi/file_system_mount_option.h"
  42 #include "webkit/common/fileapi/file_system_types.h"
  43
  44 using content::BrowserThread;
  45 using content::NavigationController;
  46 using content::RenderProcessHost;
  47 using content::WebContents;
  48 using fileapi::ExternalMountPoints;
  49 using storage_monitor::MediaStorageUtil;
  50 using storage_monitor::StorageInfo;
  51 using storage_monitor::StorageMonitor;
  52
  53 namespace {
  54
  55 struct InvalidatedGalleriesInfo {
  56   std::set<ExtensionGalleriesHost*> extension_hosts;
  57   std::set<MediaGalleryPrefId> pref_ids;
  58 };
  59
  60 // Tracks the liveness of multiple RenderProcessHosts that the caller is
  61 // interested in. Once all of the RPHs have closed or been destroyed a call
  62 // back informs the caller.
  63 class RPHReferenceManager {
  64  public:
  65   // |no_references_callback| is called when the last RenderViewHost reference
  66   // goes away. RenderViewHost references are added through ReferenceFromRVH().
  67   explicit RPHReferenceManager(const base::Closure& no_references_callback);
  68   virtual ~RPHReferenceManager();
  69
  70   // Remove all references, but don't call |no_references_callback|.
  71   void Reset() { STLDeleteValues(&observer_map_); }
  72
  73   // Returns true if there are no references;
  74   bool empty() const { return observer_map_.empty(); }
  75
  76   // Adds a reference to the passed |rvh|. Calling this multiple times with
  77   // the same |rvh| is a no-op.
  78   void ReferenceFromRVH(const content::RenderViewHost* rvh);
  79
  80  private:
  81   class RPHWebContentsObserver : public content::WebContentsObserver {
  82    public:
  83     RPHWebContentsObserver(RPHReferenceManager* manager,
  84                            WebContents* web_contents);
  85
  86    private:
  87     // content::WebContentsObserver
  88     virtual void WebContentsDestroyed() OVERRIDE;
  89     virtual void NavigationEntryCommitted(
  90         const content::LoadCommittedDetails& load_details) OVERRIDE;
  91
  92     RPHReferenceManager* manager_;
  93   };
  94
  95   class RPHObserver : public content::RenderProcessHostObserver {
  96    public:
  97     RPHObserver(RPHReferenceManager* manager, RenderProcessHost* host);
  98     virtual ~RPHObserver();
  99
 100     void AddWebContentsObserver(WebContents* web_contents);
 101     void RemoveWebContentsObserver(WebContents* web_contents);
 102     bool HasWebContentsObservers() {
 103       return observed_web_contentses_.size() > 0;
 104     }
 105
 106    private:
 107     virtual void RenderProcessHostDestroyed(RenderProcessHost* host) OVERRIDE;
 108
 109     RPHReferenceManager* manager_;
 110     RenderProcessHost* host_;
 111     typedef std::map<WebContents*, RPHWebContentsObserver*> WCObserverMap;
 112     WCObserverMap observed_web_contentses_;
 113   };
 114   typedef std::map<const RenderProcessHost*, RPHObserver*> RPHObserverMap;
 115
 116   // Handlers for observed events.
 117   void OnRenderProcessHostDestroyed(RenderProcessHost* rph);
 118   void OnWebContentsDestroyedOrNavigated(WebContents* contents);
 119
 120   // A callback to call when the last RVH reference goes away.
 121   base::Closure no_references_callback_;
 122
 123   // The set of render processes and web contents that may have references to
 124   // the file system ids this instance manages.
 125   RPHObserverMap observer_map_;
 126 };
 127
 128 RPHReferenceManager::RPHReferenceManager(
 129     const base::Closure& no_references_callback)
 130     : no_references_callback_(no_references_callback) {
 131 }
 132
 133 RPHReferenceManager::~RPHReferenceManager() {
 134   Reset();
 135 }
 136
 137 void RPHReferenceManager::ReferenceFromRVH(const content::RenderViewHost* rvh) {
 138   WebContents* contents = WebContents::FromRenderViewHost(rvh);
 139   RenderProcessHost* rph = contents->GetRenderProcessHost();
 140   RPHObserver* state = NULL;
 141   if (!ContainsKey(observer_map_, rph)) {
 142     state = new RPHObserver(this, rph);
 143     observer_map_[rph] = state;
 144   } else {
 145     state = observer_map_[rph];
 146   }
 147
 148   state->AddWebContentsObserver(contents);
 149 }
 150
 151 RPHReferenceManager::RPHWebContentsObserver::RPHWebContentsObserver(
 152     RPHReferenceManager* manager,
 153     WebContents* web_contents)
 154     : content::WebContentsObserver(web_contents),
 155       manager_(manager) {
 156 }
 157
 158 void RPHReferenceManager::RPHWebContentsObserver::WebContentsDestroyed() {
 159   manager_->OnWebContentsDestroyedOrNavigated(web_contents());
 160 }
 161
 162 void RPHReferenceManager::RPHWebContentsObserver::NavigationEntryCommitted(
 163     const content::LoadCommittedDetails& load_details) {
 164   if (load_details.is_in_page)
 165     return;
 166
 167   manager_->OnWebContentsDestroyedOrNavigated(web_contents());
 168 }
 169
 170 RPHReferenceManager::RPHObserver::RPHObserver(
 171     RPHReferenceManager* manager, RenderProcessHost* host)
 172     : manager_(manager),
 173       host_(host) {
 174   host->AddObserver(this);
 175 }
 176
 177 RPHReferenceManager::RPHObserver::~RPHObserver() {
 178   STLDeleteValues(&observed_web_contentses_);
 179   if (host_)
 180     host_->RemoveObserver(this);
 181 }
 182
 183 void RPHReferenceManager::RPHObserver::AddWebContentsObserver(
 184     WebContents* web_contents) {
 185   if (ContainsKey(observed_web_contentses_, web_contents))
 186     return;
 187
 188   RPHWebContentsObserver* observer =
 189     new RPHWebContentsObserver(manager_, web_contents);
 190   observed_web_contentses_[web_contents] = observer;
 191 }
 192
 193 void RPHReferenceManager::RPHObserver::RemoveWebContentsObserver(
 194     WebContents* web_contents) {
 195   WCObserverMap::iterator wco_iter =
 196       observed_web_contentses_.find(web_contents);
 197   DCHECK(wco_iter != observed_web_contentses_.end());
 198   delete wco_iter->second;
 199   observed_web_contentses_.erase(wco_iter);
 200 }
 201
 202 void RPHReferenceManager::RPHObserver::RenderProcessHostDestroyed(
 203     RenderProcessHost* host) {
 204   host_ = NULL;
 205   manager_->OnRenderProcessHostDestroyed(host);
 206 }
 207
 208 void RPHReferenceManager::OnRenderProcessHostDestroyed(
 209     RenderProcessHost* rph) {
 210   RPHObserverMap::iterator rph_info = observer_map_.find(rph);
 211   // This could be a potential problem if the RPH is navigated to a page on the
 212   // same renderer (triggering OnWebContentsDestroyedOrNavigated()) and then the
 213   // renderer crashes.
 214   if (rph_info == observer_map_.end()) {
 215     NOTREACHED();
 216     return;
 217   }
 218   delete rph_info->second;
 219   observer_map_.erase(rph_info);
 220   if (observer_map_.empty())
 221     no_references_callback_.Run();
 222 }
 223
 224 void RPHReferenceManager::OnWebContentsDestroyedOrNavigated(
 225     WebContents* contents) {
 226   RenderProcessHost* rph = contents->GetRenderProcessHost();
 227   RPHObserverMap::iterator rph_info = observer_map_.find(rph);
 228   DCHECK(rph_info != observer_map_.end());
 229
 230   rph_info->second->RemoveWebContentsObserver(contents);
 231   if (!rph_info->second->HasWebContentsObservers())
 232     OnRenderProcessHostDestroyed(rph);
 233 }
 234
 235 }  // namespace
 236
 237 MediaFileSystemInfo::MediaFileSystemInfo(const base::string16& fs_name,
 238                                          const base::FilePath& fs_path,
 239                                          const std::string& filesystem_id,
 240                                          MediaGalleryPrefId pref_id,
 241                                          const std::string& transient_device_id,
 242                                          bool removable,
 243                                          bool media_device)
 244     : name(fs_name),
 245       path(fs_path),
 246       fsid(filesystem_id),
 247       pref_id(pref_id),
 248       transient_device_id(transient_device_id),
 249       removable(removable),
 250       media_device(media_device) {
 251 }
 252
 253 MediaFileSystemInfo::MediaFileSystemInfo() {}
 254 MediaFileSystemInfo::~MediaFileSystemInfo() {}
 255
 256 // The main owner of this class is
 257 // |MediaFileSystemRegistry::extension_hosts_map_|, but a callback may
 258 // temporarily hold a reference.
 259 class ExtensionGalleriesHost
 260     : public base::RefCountedThreadSafe<ExtensionGalleriesHost> {
 261  public:
 262   // |no_references_callback| is called when the last RenderViewHost reference
 263   // goes away. RenderViewHost references are added through ReferenceFromRVH().
 264   ExtensionGalleriesHost(MediaFileSystemContext* file_system_context,
 265                          const base::FilePath& profile_path,
 266                          const std::string& extension_id,
 267                          const base::Closure& no_references_callback)
 268       : file_system_context_(file_system_context),
 269         profile_path_(profile_path),
 270         extension_id_(extension_id),
 271         no_references_callback_(no_references_callback),
 272         rph_refs_(base::Bind(&ExtensionGalleriesHost::CleanUp,
 273                              base::Unretained(this))) {
 274   }
 275
 276   // For each gallery in the list of permitted |galleries|, checks if the
 277   // device is attached and if so looks up or creates a file system name and
 278   // passes the information needed for the renderer to create those file
 279   // system objects to the |callback|.
 280   void GetMediaFileSystems(const MediaGalleryPrefIdSet& galleries,
 281                            const MediaGalleriesPrefInfoMap& galleries_info,
 282                            const MediaFileSystemsCallback& callback) {
 283     // Extract all the device ids so we can make sure they are attached.
 284     MediaStorageUtil::DeviceIdSet* device_ids =
 285         new MediaStorageUtil::DeviceIdSet;
 286     for (std::set<MediaGalleryPrefId>::const_iterator id = galleries.begin();
 287          id != galleries.end();
 288          ++id) {
 289       device_ids->insert(galleries_info.find(*id)->second.device_id);
 290     }
 291     MediaStorageUtil::FilterAttachedDevices(device_ids, base::Bind(
 292         &ExtensionGalleriesHost::GetMediaFileSystemsForAttachedDevices, this,
 293         base::Owned(device_ids), galleries, galleries_info, callback));
 294   }
 295
 296   // Checks if |gallery| is attached and if so, registers the file system and
 297   // then calls |callback| with the result.
 298   void RegisterMediaFileSystem(
 299       const MediaGalleryPrefInfo& gallery,
 300       const base::Callback<void(base::File::Error result)>& callback) {
 301     // Extract all the device ids so we can make sure they are attached.
 302     MediaStorageUtil::DeviceIdSet* device_ids =
 303         new MediaStorageUtil::DeviceIdSet;
 304     device_ids->insert(gallery.device_id);
 305     MediaStorageUtil::FilterAttachedDevices(device_ids, base::Bind(
 306         &ExtensionGalleriesHost::RegisterAttachedMediaFileSystem, this,
 307         base::Owned(device_ids), gallery, callback));
 308   }
 309
 310   // Revoke the file system for |id| if this extension has created one for |id|.
 311   void RevokeGalleryByPrefId(MediaGalleryPrefId id) {
 312     PrefIdFsInfoMap::iterator gallery = pref_id_map_.find(id);
 313     if (gallery == pref_id_map_.end())
 314       return;
 315
 316     file_system_context_->RevokeFileSystem(gallery->second.fsid);
 317     pref_id_map_.erase(gallery);
 318
 319     if (pref_id_map_.empty()) {
 320       rph_refs_.Reset();
 321       CleanUp();
 322     }
 323   }
 324
 325   // Indicate that the passed |rvh| will reference the file system ids created
 326   // by this class.
 327   void ReferenceFromRVH(const content::RenderViewHost* rvh) {
 328     rph_refs_.ReferenceFromRVH(rvh);
 329   }
 330
 331  private:
 332   typedef std::map<MediaGalleryPrefId, MediaFileSystemInfo> PrefIdFsInfoMap;
 333
 334   // Private destructor and friend declaration for ref counted implementation.
 335   friend class base::RefCountedThreadSafe<ExtensionGalleriesHost>;
 336
 337   virtual ~ExtensionGalleriesHost() {
 338     DCHECK(rph_refs_.empty());
 339     DCHECK(pref_id_map_.empty());
 340   }
 341
 342   void GetMediaFileSystemsForAttachedDevices(
 343       const MediaStorageUtil::DeviceIdSet* attached_devices,
 344       const MediaGalleryPrefIdSet& galleries,
 345       const MediaGalleriesPrefInfoMap& galleries_info,
 346       const MediaFileSystemsCallback& callback) {
 347     std::vector<MediaFileSystemInfo> result;
 348
 349     if (rph_refs_.empty()) {
 350       // We're actually in the middle of shutdown, and Filter...() lagging
 351       // which can invoke this method interleaved in the destruction callback
 352       // sequence and re-populate pref_id_map_.
 353       callback.Run(result);
 354       return;
 355     }
 356
 357     for (std::set<MediaGalleryPrefId>::const_iterator pref_id_it =
 358              galleries.begin();
 359          pref_id_it != galleries.end();
 360          ++pref_id_it) {
 361       const MediaGalleryPrefId& pref_id = *pref_id_it;
 362       const MediaGalleryPrefInfo& gallery_info =
 363           galleries_info.find(pref_id)->second;
 364       const std::string& device_id = gallery_info.device_id;
 365       if (!ContainsKey(*attached_devices, device_id))
 366         continue;
 367
 368       PrefIdFsInfoMap::const_iterator existing_info =
 369           pref_id_map_.find(pref_id);
 370       if (existing_info != pref_id_map_.end()) {
 371         result.push_back(existing_info->second);
 372         continue;
 373       }
 374
 375       base::FilePath path = gallery_info.AbsolutePath();
 376       if (!MediaStorageUtil::CanCreateFileSystem(device_id, path))
 377         continue;
 378
 379       std::string fs_name = MediaFileSystemBackend::ConstructMountName(
 380           profile_path_, extension_id_, pref_id);
 381       if (!file_system_context_->RegisterFileSystem(device_id, fs_name, path))
 382         continue;
 383
 384       MediaFileSystemInfo new_entry(
 385           gallery_info.GetGalleryDisplayName(),
 386           file_system_context_->GetRegisteredPath(fs_name),
 387           fs_name,
 388           pref_id,
 389           GetTransientIdForRemovableDeviceId(device_id),
 390           StorageInfo::IsRemovableDevice(device_id),
 391           StorageInfo::IsMediaDevice(device_id));
 392       result.push_back(new_entry);
 393       pref_id_map_[pref_id] = new_entry;
 394     }
 395
 396     if (result.size() == 0) {
 397       rph_refs_.Reset();
 398       CleanUp();
 399     }
 400
 401     DCHECK_EQ(pref_id_map_.size(), result.size());
 402     callback.Run(result);
 403   }
 404
 405   void RegisterAttachedMediaFileSystem(
 406       const MediaStorageUtil::DeviceIdSet* attached_device,
 407       const MediaGalleryPrefInfo& gallery,
 408       const base::Callback<void(base::File::Error result)>& callback) {
 409     base::File::Error result = base::File::FILE_ERROR_NOT_FOUND;
 410
 411     // If rph_refs is empty then we're actually in the middle of shutdown, and
 412     // Filter...() lagging which can invoke this method interleaved in the
 413     // destruction callback sequence and re-populate pref_id_map_.
 414     if (!attached_device->empty() && !rph_refs_.empty()) {
 415       std::string fs_name = MediaFileSystemBackend::ConstructMountName(
 416           profile_path_, extension_id_, gallery.pref_id);
 417       base::FilePath path = gallery.AbsolutePath();
 418       const std::string& device_id = gallery.device_id;
 419
 420       if (ContainsKey(pref_id_map_, gallery.pref_id)) {
 421         result = base::File::FILE_OK;
 422       } else if (MediaStorageUtil::CanCreateFileSystem(device_id, path) &&
 423                  file_system_context_->RegisterFileSystem(device_id, fs_name,
 424                                                           path)) {
 425         result = base::File::FILE_OK;
 426         pref_id_map_[gallery.pref_id] = MediaFileSystemInfo(
 427             gallery.GetGalleryDisplayName(),
 428             file_system_context_->GetRegisteredPath(fs_name),
 429             fs_name,
 430             gallery.pref_id,
 431             GetTransientIdForRemovableDeviceId(device_id),
 432             StorageInfo::IsRemovableDevice(device_id),
 433             StorageInfo::IsMediaDevice(device_id));
 434       }
 435     }
 436
 437     if (pref_id_map_.empty()) {
 438       rph_refs_.Reset();
 439       CleanUp();
 440     }
 441     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
 442                             base::Bind(callback, result));
 443   }
 444
 445   std::string GetTransientIdForRemovableDeviceId(const std::string& device_id) {
 446     if (!StorageInfo::IsRemovableDevice(device_id))
 447       return std::string();
 448
 449     return StorageMonitor::GetInstance()->GetTransientIdForDeviceId(device_id);
 450   }
 451
 452   void CleanUp() {
 453     DCHECK(rph_refs_.empty());
 454     for (PrefIdFsInfoMap::const_iterator it = pref_id_map_.begin();
 455          it != pref_id_map_.end();
 456          ++it) {
 457       file_system_context_->RevokeFileSystem(it->second.fsid);
 458     }
 459     pref_id_map_.clear();
 460
 461     no_references_callback_.Run();
 462   }
 463
 464   // MediaFileSystemRegistry owns |this| and |file_system_context_|, so it's
 465   // safe to store a raw pointer.
 466   MediaFileSystemContext* file_system_context_;
 467
 468   // Path for the active profile.
 469   const base::FilePath profile_path_;
 470
 471   // Id of the extension this host belongs to.
 472   const std::string extension_id_;
 473
 474   // A callback to call when the last RVH reference goes away.
 475   base::Closure no_references_callback_;
 476
 477   // A map from the gallery preferences id to the file system information.
 478   PrefIdFsInfoMap pref_id_map_;
 479
 480   // The set of render processes and web contents that may have references to
 481   // the file system ids this instance manages.
 482   RPHReferenceManager rph_refs_;
 483
 484   DISALLOW_COPY_AND_ASSIGN(ExtensionGalleriesHost);
 485 };
 486
 487 /******************
 488  * Public methods
 489  ******************/
 490
 491 void MediaFileSystemRegistry::GetMediaFileSystemsForExtension(
 492     const content::RenderViewHost* rvh,
 493     const extensions::Extension* extension,
 494     const MediaFileSystemsCallback& callback) {
 495   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 496
 497   Profile* profile =
 498       Profile::FromBrowserContext(rvh->GetProcess()->GetBrowserContext());
 499   MediaGalleriesPreferences* preferences = GetPreferences(profile);
 500   MediaGalleryPrefIdSet galleries =
 501       preferences->GalleriesForExtension(*extension);
 502
 503   if (galleries.empty()) {
 504     callback.Run(std::vector<MediaFileSystemInfo>());
 505     return;
 506   }
 507
 508   ExtensionGalleriesHost* extension_host =
 509       GetExtensionGalleryHost(profile, preferences, extension->id());
 510
 511   // This must come before the GetMediaFileSystems call to make sure the
 512   // RVH of the context is referenced before the filesystems are retrieved.
 513   extension_host->ReferenceFromRVH(rvh);
 514
 515   extension_host->GetMediaFileSystems(galleries, preferences->known_galleries(),
 516                                       callback);
 517 }
 518
 519 void MediaFileSystemRegistry::RegisterMediaFileSystemForExtension(
 520     const content::RenderViewHost* rvh,
 521     const extensions::Extension* extension,
 522     MediaGalleryPrefId pref_id,
 523     const base::Callback<void(base::File::Error result)>& callback) {
 524   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 525   DCHECK_NE(kInvalidMediaGalleryPrefId, pref_id);
 526
 527   Profile* profile =
 528       Profile::FromBrowserContext(rvh->GetProcess()->GetBrowserContext());
 529   MediaGalleriesPreferences* preferences = GetPreferences(profile);
 530   MediaGalleriesPrefInfoMap::const_iterator gallery =
 531       preferences->known_galleries().find(pref_id);
 532   MediaGalleryPrefIdSet permitted_galleries =
 533       preferences->GalleriesForExtension(*extension);
 534
 535   if (gallery == preferences->known_galleries().end() ||
 536       !ContainsKey(permitted_galleries, pref_id)) {
 537     BrowserThread::PostTask(
 538         BrowserThread::IO, FROM_HERE,
 539         base::Bind(callback, base::File::FILE_ERROR_NOT_FOUND));
 540     return;
 541   }
 542
 543   ExtensionGalleriesHost* extension_host =
 544       GetExtensionGalleryHost(profile, preferences, extension->id());
 545
 546   // This must come before the GetMediaFileSystems call to make sure the
 547   // RVH of the context is referenced before the filesystems are retrieved.
 548   extension_host->ReferenceFromRVH(rvh);
 549
 550   extension_host->RegisterMediaFileSystem(gallery->second, callback);
 551 }
 552
 553 MediaGalleriesPreferences* MediaFileSystemRegistry::GetPreferences(
 554     Profile* profile) {
 555   // Create an empty ExtensionHostMap for this profile on first initialization.
 556   if (!ContainsKey(extension_hosts_map_, profile)) {
 557     extension_hosts_map_[profile] = ExtensionHostMap();
 558     media_galleries::UsageCount(media_galleries::PROFILES_WITH_USAGE);
 559   }
 560
 561   return MediaGalleriesPreferencesFactory::GetForProfile(profile);
 562 }
 563
 564 MediaScanManager* MediaFileSystemRegistry::media_scan_manager() {
 565   if (!media_scan_manager_)
 566     media_scan_manager_.reset(new MediaScanManager);
 567   return media_scan_manager_.get();
 568 }
 569
 570 void MediaFileSystemRegistry::OnRemovableStorageDetached(
 571     const StorageInfo& info) {
 572   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 573
 574   // Since revoking a gallery in the ExtensionGalleriesHost may cause it
 575   // to be removed from the map and therefore invalidate any iterator pointing
 576   // to it, this code first copies all the invalid gallery ids and the
 577   // extension hosts in which they may appear (per profile) and revoked it in
 578   // a second step.
 579   std::vector<InvalidatedGalleriesInfo> invalid_galleries_info;
 580
 581   for (ExtensionGalleriesHostMap::iterator profile_it =
 582            extension_hosts_map_.begin();
 583        profile_it != extension_hosts_map_.end();
 584        ++profile_it) {
 585     MediaGalleriesPreferences* preferences = GetPreferences(profile_it->first);
 586     // If |preferences| is not yet initialized, it won't contain any galleries.
 587     if (!preferences->IsInitialized())
 588       continue;
 589
 590     InvalidatedGalleriesInfo invalid_galleries_in_profile;
 591     invalid_galleries_in_profile.pref_ids =
 592         preferences->LookUpGalleriesByDeviceId(info.device_id());
 593
 594     for (ExtensionHostMap::const_iterator extension_host_it =
 595              profile_it->second.begin();
 596          extension_host_it != profile_it->second.end();
 597          ++extension_host_it) {
 598       invalid_galleries_in_profile.extension_hosts.insert(
 599           extension_host_it->second.get());
 600     }
 601
 602     invalid_galleries_info.push_back(invalid_galleries_in_profile);
 603   }
 604
 605   for (size_t i = 0; i < invalid_galleries_info.size(); i++) {
 606     for (std::set<ExtensionGalleriesHost*>::const_iterator extension_host_it =
 607              invalid_galleries_info[i].extension_hosts.begin();
 608          extension_host_it != invalid_galleries_info[i].extension_hosts.end();
 609          ++extension_host_it) {
 610       for (std::set<MediaGalleryPrefId>::const_iterator pref_id_it =
 611                invalid_galleries_info[i].pref_ids.begin();
 612            pref_id_it != invalid_galleries_info[i].pref_ids.end();
 613            ++pref_id_it) {
 614         (*extension_host_it)->RevokeGalleryByPrefId(*pref_id_it);
 615       }
 616     }
 617   }
 618 }
 619
 620 /******************
 621  * Private methods
 622  ******************/
 623
 624 class MediaFileSystemRegistry::MediaFileSystemContextImpl
 625     : public MediaFileSystemContext {
 626  public:
 627   MediaFileSystemContextImpl() {}
 628   virtual ~MediaFileSystemContextImpl() {}
 629
 630   virtual bool RegisterFileSystem(const std::string& device_id,
 631                                   const std::string& fs_name,
 632                                   const base::FilePath& path) OVERRIDE {
 633     if (StorageInfo::IsMassStorageDevice(device_id)) {
 634       return RegisterFileSystemForMassStorage(device_id, fs_name, path);
 635     } else {
 636       return RegisterFileSystemForMTPDevice(device_id, fs_name, path);
 637     }
 638   }
 639
 640   virtual void RevokeFileSystem(const std::string& fs_name) OVERRIDE {
 641     ImportedMediaGalleryRegistry* imported_registry =
 642         ImportedMediaGalleryRegistry::GetInstance();
 643     if (imported_registry->RevokeImportedFilesystemOnUIThread(fs_name))
 644       return;
 645
 646     ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(fs_name);
 647
 648     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
 649         &MTPDeviceMapService::RevokeMTPFileSystem,
 650         base::Unretained(MTPDeviceMapService::GetInstance()),
 651         fs_name));
 652   }
 653
 654   virtual base::FilePath GetRegisteredPath(
 655       const std::string& fs_name) const OVERRIDE {
 656     base::FilePath result;
 657     if (!ExternalMountPoints::GetSystemInstance()->GetRegisteredPath(fs_name,
 658                                                                      &result)) {
 659       return base::FilePath();
 660     }
 661     return result;
 662   }
 663
 664  private:
 665   // Registers and returns the file system id for the mass storage device
 666   // specified by |device_id| and |path|.
 667   bool RegisterFileSystemForMassStorage(const std::string& device_id,
 668                                         const std::string& fs_name,
 669                                         const base::FilePath& path) {
 670     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 671     DCHECK(StorageInfo::IsMassStorageDevice(device_id));
 672
 673     // Sanity checks for |path|.
 674     CHECK(path.IsAbsolute());
 675     CHECK(!path.ReferencesParent());
 676
 677     // TODO(gbillock): refactor ImportedMediaGalleryRegistry to delegate this
 678     // call tree, probably by having it figure out by device id what
 679     // registration is needed, or having per-device-type handlers at the
 680     // next higher level.
 681     bool result = false;
 682     if (StorageInfo::IsITunesDevice(device_id)) {
 683       ImportedMediaGalleryRegistry* registry =
 684           ImportedMediaGalleryRegistry::GetInstance();
 685       result = registry->RegisterITunesFilesystemOnUIThread(fs_name, path);
 686     } else if (StorageInfo::IsPicasaDevice(device_id)) {
 687       ImportedMediaGalleryRegistry* registry =
 688           ImportedMediaGalleryRegistry::GetInstance();
 689       result = registry->RegisterPicasaFilesystemOnUIThread(fs_name, path);
 690     } else if (StorageInfo::IsIPhotoDevice(device_id)) {
 691       ImportedMediaGalleryRegistry* registry =
 692           ImportedMediaGalleryRegistry::GetInstance();
 693       result = registry->RegisterIPhotoFilesystemOnUIThread(fs_name, path);
 694     } else {
 695       result = ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
 696           fs_name, fileapi::kFileSystemTypeNativeMedia,
 697           fileapi::FileSystemMountOption(), path);
 698     }
 699     return result;
 700   }
 701
 702   bool RegisterFileSystemForMTPDevice(const std::string& device_id,
 703                                       const std::string fs_name,
 704                                       const base::FilePath& path) {
 705     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 706     DCHECK(!StorageInfo::IsMassStorageDevice(device_id));
 707
 708     // Sanity checks for |path|.
 709     CHECK(MediaStorageUtil::CanCreateFileSystem(device_id, path));
 710     bool result = ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
 711         fs_name, fileapi::kFileSystemTypeDeviceMedia,
 712         fileapi::FileSystemMountOption(), path);
 713     CHECK(result);
 714     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
 715         &MTPDeviceMapService::RegisterMTPFileSystem,
 716         base::Unretained(MTPDeviceMapService::GetInstance()),
 717         path.value(), fs_name));
 718     return result;
 719   }
 720
 721   DISALLOW_COPY_AND_ASSIGN(MediaFileSystemContextImpl);
 722 };
 723
 724 // Constructor in 'private' section because depends on private class definition.
 725 MediaFileSystemRegistry::MediaFileSystemRegistry()
 726     : file_system_context_(new MediaFileSystemContextImpl) {
 727   StorageMonitor::GetInstance()->AddObserver(this);
 728 }
 729
 730 MediaFileSystemRegistry::~MediaFileSystemRegistry() {
 731   // TODO(gbillock): This is needed because the unit test uses the
 732   // g_browser_process registry. We should create one in the unit test,
 733   // and then can remove this.
 734   if (StorageMonitor::GetInstance())
 735     StorageMonitor::GetInstance()->RemoveObserver(this);
 736 }
 737
 738 void MediaFileSystemRegistry::OnPermissionRemoved(
 739     MediaGalleriesPreferences* prefs,
 740     const std::string& extension_id,
 741     MediaGalleryPrefId pref_id) {
 742   Profile* profile = prefs->profile();
 743   ExtensionGalleriesHostMap::const_iterator host_map_it =
 744       extension_hosts_map_.find(profile);
 745   DCHECK(host_map_it != extension_hosts_map_.end());
 746   const ExtensionHostMap& extension_host_map = host_map_it->second;
 747   ExtensionHostMap::const_iterator gallery_host_it =
 748       extension_host_map.find(extension_id);
 749   if (gallery_host_it == extension_host_map.end())
 750     return;
 751   gallery_host_it->second->RevokeGalleryByPrefId(pref_id);
 752 }
 753
 754 void MediaFileSystemRegistry::OnGalleryRemoved(
 755     MediaGalleriesPreferences* prefs,
 756     MediaGalleryPrefId pref_id) {
 757   Profile* profile = prefs->profile();
 758   // Get the Extensions, MediaGalleriesPreferences and ExtensionHostMap for
 759   // |profile|.
 760   const ExtensionService* extension_service =
 761       extensions::ExtensionSystem::Get(profile)->extension_service();
 762   const extensions::ExtensionSet* extensions_set =
 763       extension_service->extensions();
 764   ExtensionGalleriesHostMap::const_iterator host_map_it =
 765       extension_hosts_map_.find(profile);
 766   DCHECK(host_map_it != extension_hosts_map_.end());
 767   const ExtensionHostMap& extension_host_map = host_map_it->second;
 768
 769   // Go through ExtensionHosts, and remove indicated gallery, if any.
 770   // RevokeGalleryByPrefId() may end up deleting from |extension_host_map| and
 771   // even delete |extension_host_map| altogether. So do this in two loops to
 772   // avoid using an invalidated iterator or deleted map.
 773   std::vector<const extensions::Extension*> extensions;
 774   for (ExtensionHostMap::const_iterator it = extension_host_map.begin();
 775        it != extension_host_map.end();
 776        ++it) {
 777     extensions.push_back(extensions_set->GetByID(it->first));
 778   }
 779   for (size_t i = 0; i < extensions.size(); ++i) {
 780     if (!ContainsKey(extension_hosts_map_, profile))
 781       break;
 782     ExtensionHostMap::const_iterator gallery_host_it =
 783         extension_host_map.find(extensions[i]->id());
 784     if (gallery_host_it == extension_host_map.end())
 785       continue;
 786     gallery_host_it->second->RevokeGalleryByPrefId(pref_id);
 787   }
 788 }
 789
 790 ExtensionGalleriesHost* MediaFileSystemRegistry::GetExtensionGalleryHost(
 791     Profile* profile,
 792     MediaGalleriesPreferences* preferences,
 793     const std::string& extension_id) {
 794   ExtensionGalleriesHostMap::iterator extension_hosts =
 795       extension_hosts_map_.find(profile);
 796   // GetPreferences(), which had to be called because preferences is an
 797   // argument, ensures that profile is in the map.
 798   DCHECK(extension_hosts != extension_hosts_map_.end());
 799   if (extension_hosts->second.empty())
 800     preferences->AddGalleryChangeObserver(this);
 801
 802   ExtensionGalleriesHost* result = extension_hosts->second[extension_id].get();
 803   if (!result) {
 804     result = new ExtensionGalleriesHost(
 805         file_system_context_.get(),
 806         profile->GetPath(),
 807         extension_id,
 808         base::Bind(&MediaFileSystemRegistry::OnExtensionGalleriesHostEmpty,
 809                    base::Unretained(this),
 810                    profile,
 811                    extension_id));
 812     extension_hosts_map_[profile][extension_id] = result;
 813   }
 814   return result;
 815 }
 816
 817 void MediaFileSystemRegistry::OnExtensionGalleriesHostEmpty(
 818     Profile* profile, const std::string& extension_id) {
 819   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 820
 821   ExtensionGalleriesHostMap::iterator extension_hosts =
 822       extension_hosts_map_.find(profile);
 823   DCHECK(extension_hosts != extension_hosts_map_.end());
 824   ExtensionHostMap::size_type erase_count =
 825       extension_hosts->second.erase(extension_id);
 826   DCHECK_EQ(1U, erase_count);
 827   if (extension_hosts->second.empty()) {
 828     // When a profile has no ExtensionGalleriesHosts left, remove the
 829     // matching gallery-change-watcher since it is no longer needed. Leave the
 830     // |extension_hosts| entry alone, since it indicates the profile has been
 831     // previously used.
 832     MediaGalleriesPreferences* preferences = GetPreferences(profile);
 833     preferences->RemoveGalleryChangeObserver(this);
 834   }
 835 }