root/chrome/browser/media_galleries/imported_media_gallery_registry.cc

DEFINITIONS

1. GetInstance
2. Initialize
3. RegisterPicasaFilesystemOnUIThread
4. RegisterITunesFilesystemOnUIThread
5. RegisterIPhotoFilesystemOnUIThread
6. RevokeImportedFilesystemOnUIThread
7. ImportedRoot
8. PicasaDataProvider
9. ITunesDataProvider
10. IPhotoDataProvider
11. RegisterPicasaFileSystem
12. RevokePicasaFileSystem
13. RegisterITunesFileSystem
14. RevokeITunesFileSystem
15. RegisterIPhotoFileSystem
16. RevokeIPhotoFileSystem

// Copyright 2013 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/media_galleries/imported_media_gallery_registry.h"

#include "base/bind.h"
#include "base/file_util.h"
#include "base/logging.h"
#include "chrome/browser/media_galleries/fileapi/iphoto_data_provider.h"
#include "chrome/browser/media_galleries/fileapi/itunes_data_provider.h"
#include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
#include "chrome/browser/media_galleries/fileapi/picasa_data_provider.h"
#include "chrome/common/extensions/extension_constants.h"
#include "content/public/browser/browser_thread.h"
#include "webkit/browser/fileapi/external_mount_points.h"
#include "webkit/common/fileapi/file_system_mount_option.h"

using base::Bind;
using fileapi::ExternalMountPoints;

namespace {

static base::LazyInstance<ImportedMediaGalleryRegistry>::Leaky
g_imported_media_gallery_registry = LAZY_INSTANCE_INITIALIZER;

}  // namespace

// static
ImportedMediaGalleryRegistry* ImportedMediaGalleryRegistry::GetInstance() {
  return g_imported_media_gallery_registry.Pointer();
}

void ImportedMediaGalleryRegistry::Initialize() {
  base::ThreadRestrictions::AssertIOAllowed();
  if (imported_root_.empty()) {
    if (!base::CreateTemporaryFile(&imported_root_))
      imported_root_ = base::FilePath();
    // TODO(vandebo) Setting the permissions of |imported_root_| in CPSP to
    // zero would be an extra step to ensure permissions are correctly
    // enforced.
  }
}

bool ImportedMediaGalleryRegistry::RegisterPicasaFilesystemOnUIThread(
    const std::string& fs_name, const base::FilePath& database_path) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  DCHECK(!fs_name.empty());
  DCHECK(!database_path.empty());

  bool result = false;

#if defined(OS_WIN) || defined(OS_MACOSX)
  base::FilePath root = ImportedRoot();
  if (root.empty())
    return false;
  result = ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
      fs_name, fileapi::kFileSystemTypePicasa, fileapi::FileSystemMountOption(),
      root.AppendASCII("picasa"));
  if (!result)
    return result;

  picasa_fs_names_.insert(fs_name);

  if (picasa_fs_names_.size() == 1) {
    MediaFileSystemBackend::MediaTaskRunner()->PostTask(
        FROM_HERE,
        Bind(&ImportedMediaGalleryRegistry::RegisterPicasaFileSystem,
             base::Unretained(this), database_path));
#ifndef NDEBUG
    picasa_database_path_ = database_path;
  } else {
    DCHECK_EQ(picasa_database_path_.value(), database_path.value());
#endif
  }
#endif  // defined(OS_WIN) || defined(OS_MACOSX)

  return result;
}

bool ImportedMediaGalleryRegistry::RegisterITunesFilesystemOnUIThread(
    const std::string& fs_name, const base::FilePath& library_xml_path) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  DCHECK(!library_xml_path.empty());

  bool result = false;

#if defined(OS_WIN) || defined(OS_MACOSX)
  base::FilePath root = ImportedRoot();
  if (root.empty())
    return false;
  result = ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
      fs_name, fileapi::kFileSystemTypeItunes, fileapi::FileSystemMountOption(),
      root.AppendASCII("itunes"));
  if (!result)
    return result;

  itunes_fs_names_.insert(fs_name);

  if (itunes_fs_names_.size() == 1) {
    MediaFileSystemBackend::MediaTaskRunner()->PostTask(
        FROM_HERE,
        Bind(&ImportedMediaGalleryRegistry::RegisterITunesFileSystem,
             base::Unretained(this), library_xml_path));
#ifndef NDEBUG
    itunes_xml_library_path_ = library_xml_path;
  } else {
    DCHECK_EQ(itunes_xml_library_path_.value(), library_xml_path.value());
#endif
  }
#endif  // defined(OS_WIN) || defined(OS_MACOSX)

  return result;
}

bool ImportedMediaGalleryRegistry::RegisterIPhotoFilesystemOnUIThread(
    const std::string& fs_name, const base::FilePath& library_xml_path) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  DCHECK(!library_xml_path.empty());

  bool result = false;

  // TODO(gbillock): Investigate how to refactor this to reduce duplicated
  // code.
#if defined(OS_MACOSX)
  base::FilePath root = ImportedRoot();
  if (root.empty())
    return false;
  result = ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
      fs_name, fileapi::kFileSystemTypeIphoto, fileapi::FileSystemMountOption(),
      root.AppendASCII("iphoto"));
  if (!result)
    return result;

  iphoto_fs_names_.insert(fs_name);

  if (iphoto_fs_names_.size() == 1) {
    MediaFileSystemBackend::MediaTaskRunner()->PostTask(
        FROM_HERE,
        Bind(&ImportedMediaGalleryRegistry::RegisterIPhotoFileSystem,
             base::Unretained(this), library_xml_path));
#ifndef NDEBUG
    iphoto_xml_library_path_ = library_xml_path;
  } else {
    DCHECK_EQ(iphoto_xml_library_path_.value(), library_xml_path.value());
#endif
  }
#endif  // defined(OS_MACOSX)

  return result;
}

bool ImportedMediaGalleryRegistry::RevokeImportedFilesystemOnUIThread(
    const std::string& fs_name) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

#if defined(OS_WIN) || defined(OS_MACOSX)
  if (picasa_fs_names_.erase(fs_name)) {
    if (picasa_fs_names_.empty()) {
      MediaFileSystemBackend::MediaTaskRunner()->PostTask(
          FROM_HERE,
          Bind(&ImportedMediaGalleryRegistry::RevokePicasaFileSystem,
               base::Unretained(this)));
    }
    return ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(fs_name);
  }

  if (itunes_fs_names_.erase(fs_name)) {
    if (itunes_fs_names_.empty()) {
      MediaFileSystemBackend::MediaTaskRunner()->PostTask(
          FROM_HERE,
          Bind(&ImportedMediaGalleryRegistry::RevokeITunesFileSystem,
               base::Unretained(this)));
    }
    return ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(fs_name);
  }
#endif  // defined(OS_WIN) || defined(OS_MACOSX)

#if defined(OS_MACOSX)
  if (iphoto_fs_names_.erase(fs_name)) {
    if (iphoto_fs_names_.empty()) {
      MediaFileSystemBackend::MediaTaskRunner()->PostTask(
          FROM_HERE,
          Bind(&ImportedMediaGalleryRegistry::RevokeIPhotoFileSystem,
               base::Unretained(this)));
    }
    return ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(fs_name);
  }
#endif  // defined(OS_MACOSX)

  return false;
}

base::FilePath ImportedMediaGalleryRegistry::ImportedRoot() {
  DCHECK(!imported_root_.empty());
  return imported_root_;
}

#if defined(OS_WIN) || defined(OS_MACOSX)
// static
picasa::PicasaDataProvider*
ImportedMediaGalleryRegistry::PicasaDataProvider() {
  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
  DCHECK(GetInstance()->picasa_data_provider_);
  return GetInstance()->picasa_data_provider_.get();
}

// static
itunes::ITunesDataProvider*
ImportedMediaGalleryRegistry::ITunesDataProvider() {
  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
  DCHECK(GetInstance()->itunes_data_provider_);
  return GetInstance()->itunes_data_provider_.get();
}
#endif  // defined(OS_WIN) || defined(OS_MACOSX)

#if defined(OS_MACOSX)
// static
iphoto::IPhotoDataProvider*
ImportedMediaGalleryRegistry::IPhotoDataProvider() {
  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
  DCHECK(GetInstance()->iphoto_data_provider_);
  return GetInstance()->iphoto_data_provider_.get();
}
#endif  // defined(OS_MACOSX)

ImportedMediaGalleryRegistry::ImportedMediaGalleryRegistry() {}

ImportedMediaGalleryRegistry::~ImportedMediaGalleryRegistry() {
  if (!imported_root_.empty())
    base::DeleteFile(imported_root_, false);
#if defined(OS_WIN) || defined(OS_MACOSX)
  DCHECK_EQ(0U, picasa_fs_names_.size());
  DCHECK_EQ(0U, itunes_fs_names_.size());
#endif  // defined(OS_WIN) || defined(OS_MACOSX)
#if defined(OS_MACOSX)
  DCHECK_EQ(0U, iphoto_fs_names_.size());
#endif  // defined(OS_MACOSX)
}

#if defined(OS_WIN) || defined(OS_MACOSX)
void ImportedMediaGalleryRegistry::RegisterPicasaFileSystem(
    const base::FilePath& database_path) {
  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
  DCHECK(!picasa_data_provider_);
  picasa_data_provider_.reset(new picasa::PicasaDataProvider(database_path));
}

void ImportedMediaGalleryRegistry::RevokePicasaFileSystem() {
  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
  DCHECK(picasa_data_provider_);
  picasa_data_provider_.reset();
}

void ImportedMediaGalleryRegistry::RegisterITunesFileSystem(
    const base::FilePath& xml_library_path) {
  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
  DCHECK(!itunes_data_provider_);
  itunes_data_provider_.reset(new itunes::ITunesDataProvider(xml_library_path));
}

void ImportedMediaGalleryRegistry::RevokeITunesFileSystem() {
  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
  DCHECK(itunes_data_provider_);
  itunes_data_provider_.reset();
}
#endif  // defined(OS_WIN) || defined(OS_MACOSX)

#if defined(OS_MACOSX)
void ImportedMediaGalleryRegistry::RegisterIPhotoFileSystem(
    const base::FilePath& xml_library_path) {
  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
  DCHECK(!iphoto_data_provider_);
  iphoto_data_provider_.reset(new iphoto::IPhotoDataProvider(xml_library_path));
}

void ImportedMediaGalleryRegistry::RevokeIPhotoFileSystem() {
  DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
  DCHECK(iphoto_data_provider_);
  iphoto_data_provider_.reset();
}
#endif  // defined(OS_MACOSX)