Media Galleries Partial Deprecation: Remove scan functionality.

chrome/browser/extensions/api/media_galleries/media_galleries_api.cc

 // Copyright (c) 2012 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.
 
 // Implements the Chrome Extensions Media Galleries API.
 
 #include "chrome/browser/extensions/api/media_galleries/media_galleries_api.h"
 
 #include <stddef.h>
 #include <set>
@@ skipping 13 matching lines @@
 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
 #include "chrome/browser/extensions/blob_reader.h"
 #include "chrome/browser/extensions/chrome_extension_function_details.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.h"
 #include "chrome/browser/media_galleries/gallery_watch_manager.h"
 #include "chrome/browser/media_galleries/media_file_system_registry.h"
 #include "chrome/browser/media_galleries/media_galleries_histograms.h"
 #include "chrome/browser/media_galleries/media_galleries_permission_controller.h"
 #include "chrome/browser/media_galleries/media_galleries_preferences.h"
-#include "chrome/browser/media_galleries/media_galleries_scan_result_controller.h"
-#include "chrome/browser/media_galleries/media_scan_manager.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/common/extensions/api/media_galleries.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/storage_monitor/storage_info.h"
 #include "content/public/browser/blob_handle.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 29 matching lines @@
 
 namespace {
 
 const char kDisallowedByPolicy[] =
     "Media Galleries API is disallowed by policy: ";
 const char kFailedToSetGalleryPermission[] =
     "Failed to set gallery permission.";
 const char kInvalidGalleryIdMsg[] = "Invalid gallery id.";
 const char kMissingEventListener[] = "Missing event listener registration.";
 const char kNonExistentGalleryId[] = "Non-existent gallery id.";
-const char kNoScanPermission[] = "No permission to scan.";
 
 const char kDeviceIdKey[] = "deviceId";
 const char kGalleryIdKey[] = "galleryId";
 const char kIsAvailableKey[] = "isAvailable";
 const char kIsMediaDeviceKey[] = "isMediaDevice";
 const char kIsRemovableKey[] = "isRemovable";
 const char kNameKey[] = "name";
 
 const char kMetadataKey[] = "metadata";
 const char kAttachedImagesBlobInfoKey[] = "attachedImagesBlobInfo";
 const char kBlobUUIDKey[] = "blobUUID";
 const char kTypeKey[] = "type";
 const char kSizeKey[] = "size";
 
 const char kInvalidGalleryId[] = "-1";
 
 MediaFileSystemRegistry* media_file_system_registry() {
   return g_browser_process->media_file_system_registry();
 }
 
 GalleryWatchManager* gallery_watch_manager() {
   return media_file_system_registry()->gallery_watch_manager();
 }
 
-MediaScanManager* media_scan_manager() {
-  return media_file_system_registry()->media_scan_manager();
-}
-
 // Checks whether the MediaGalleries API is currently accessible (it may be
 // disallowed even if an extension has the requisite permission). Then
 // initializes the MediaGalleriesPreferences
 bool Setup(Profile* profile, std::string* error, base::Closure callback) {
   if (!ChromeSelectFilePolicy::FileSelectDialogsAllowed()) {
     *error = std::string(kDisallowedByPolicy) +
         prefs::kAllowFileSelectionDialogs;
     return false;
   }
 
@@ skipping 86 matching lines @@
         if (has_copy_to_permission) {
           policy->GrantCopyInto(child_id, filesystems[i].path);
         }
       }
     }
   }
 
   return list.release();
 }
 
-bool CheckScanPermission(const extensions::Extension* extension,
-                         std::string* error) {
-  DCHECK(extension);
-  DCHECK(error);
-  MediaGalleriesPermission::CheckParam scan_param(
-      MediaGalleriesPermission::kScanPermission);
-  bool has_scan_permission =
-      extension->permissions_data()->CheckAPIPermissionWithParam(
-          APIPermission::kMediaGalleries, &scan_param);
-  if (!has_scan_permission)
-    *error = kNoScanPermission;
-  return has_scan_permission;
-}
-
 class SelectDirectoryDialog : public ui::SelectFileDialog::Listener,
                               public base::RefCounted<SelectDirectoryDialog> {
  public:
   // Selected file path, or an empty path if the user canceled.
   typedef base::Callback<void(const base::FilePath&)> Callback;
 
   SelectDirectoryDialog(WebContents* web_contents, const Callback& callback)
       : web_contents_(web_contents),
         callback_(callback) {
     select_file_dialog_ = ui::SelectFileDialog::Create(
@@ skipping 47 matching lines @@
 MediaGalleriesEventRouter::MediaGalleriesEventRouter(
     content::BrowserContext* context)
     : profile_(Profile::FromBrowserContext(context)), weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(profile_);
 
   EventRouter::Get(profile_)->RegisterObserver(
       this, MediaGalleries::OnGalleryChanged::kEventName);
 
   gallery_watch_manager()->AddObserver(profile_, this);
-  media_scan_manager()->AddObserver(profile_, this);
 }
 
 MediaGalleriesEventRouter::~MediaGalleriesEventRouter() {
 }
 
 void MediaGalleriesEventRouter::Shutdown() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   EventRouter::Get(profile_)->UnregisterObserver(this);
 
   gallery_watch_manager()->RemoveObserver(profile_);
-  media_scan_manager()->RemoveObserver(profile_);
-  media_scan_manager()->CancelScansForProfile(profile_);
 }
 
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<MediaGalleriesEventRouter> > g_factory =
     LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<MediaGalleriesEventRouter>*
 MediaGalleriesEventRouter::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 // static
 MediaGalleriesEventRouter* MediaGalleriesEventRouter::Get(
     content::BrowserContext* context) {
   DCHECK(media_file_system_registry()
              ->GetPreferences(Profile::FromBrowserContext(context))
              ->IsInitialized());
   return BrowserContextKeyedAPIFactory<MediaGalleriesEventRouter>::Get(context);
 }
 
 bool MediaGalleriesEventRouter::ExtensionHasGalleryChangeListener(
     const std::string& extension_id) const {
   return EventRouter::Get(profile_)->ExtensionHasEventListener(
       extension_id, MediaGalleries::OnGalleryChanged::kEventName);
 }
 
-bool MediaGalleriesEventRouter::ExtensionHasScanProgressListener(
-    const std::string& extension_id) const {
-  return EventRouter::Get(profile_)->ExtensionHasEventListener(
-      extension_id, MediaGalleries::OnScanProgress::kEventName);
-}
-
-void MediaGalleriesEventRouter::OnScanStarted(const std::string& extension_id) {
-  MediaGalleries::ScanProgressDetails details;
-  details.type = MediaGalleries::SCAN_PROGRESS_TYPE_START;
-  DispatchEventToExtension(extension_id,
-                           events::MEDIA_GALLERIES_ON_SCAN_PROGRESS,
-                           MediaGalleries::OnScanProgress::kEventName,
-                           MediaGalleries::OnScanProgress::Create(details));
-}
-
-void MediaGalleriesEventRouter::OnScanCancelled(
-    const std::string& extension_id) {
-  MediaGalleries::ScanProgressDetails details;
-  details.type = MediaGalleries::SCAN_PROGRESS_TYPE_CANCEL;
-  DispatchEventToExtension(extension_id,
-                           events::MEDIA_GALLERIES_ON_SCAN_PROGRESS,
-                           MediaGalleries::OnScanProgress::kEventName,
-                           MediaGalleries::OnScanProgress::Create(details));
-}
-
-void MediaGalleriesEventRouter::OnScanFinished(
-    const std::string& extension_id, int gallery_count,
-    const MediaGalleryScanResult& file_counts) {
-  media_galleries::UsageCount(media_galleries::SCAN_FINISHED);
-  MediaGalleries::ScanProgressDetails details;
-  details.type = MediaGalleries::SCAN_PROGRESS_TYPE_FINISH;
-  details.gallery_count.reset(new int(gallery_count));
-  details.audio_count.reset(new int(file_counts.audio_count));
-  details.image_count.reset(new int(file_counts.image_count));
-  details.video_count.reset(new int(file_counts.video_count));
-  DispatchEventToExtension(extension_id,
-                           events::MEDIA_GALLERIES_ON_SCAN_PROGRESS,
-                           MediaGalleries::OnScanProgress::kEventName,
-                           MediaGalleries::OnScanProgress::Create(details));
-}
-
-void MediaGalleriesEventRouter::OnScanError(
-    const std::string& extension_id) {
-  MediaGalleries::ScanProgressDetails details;
-  details.type = MediaGalleries::SCAN_PROGRESS_TYPE_ERROR;
-  DispatchEventToExtension(extension_id,
-                           events::MEDIA_GALLERIES_ON_SCAN_PROGRESS,
-                           MediaGalleries::OnScanProgress::kEventName,
-                           MediaGalleries::OnScanProgress::Create(details));
-}
-
 void MediaGalleriesEventRouter::DispatchEventToExtension(
     const std::string& extension_id,
     events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   EventRouter* router = EventRouter::Get(profile_);
   if (!router->ExtensionHasEventListener(extension_id, event_name))
     return;
@@ skipping 354 matching lines @@
   bool dropped = preferences->SetGalleryPermissionForExtension(
       *extension(), pref_id, false);
   if (dropped)
     SetResult(new base::StringValue(base::Uint64ToString(pref_id)));
   else
     error_ = kFailedToSetGalleryPermission;
   SendResponse(dropped);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-//                 MediaGalleriesStartMediaScanFunction                      //
-///////////////////////////////////////////////////////////////////////////////
-MediaGalleriesStartMediaScanFunction::~MediaGalleriesStartMediaScanFunction() {}
-
-bool MediaGalleriesStartMediaScanFunction::RunAsync() {
-  media_galleries::UsageCount(media_galleries::START_MEDIA_SCAN);
-  if (!CheckScanPermission(extension(), &error_)) {
-    MediaGalleriesEventRouter::Get(GetProfile())
-        ->OnScanError(extension()->id());
-    return false;
-  }
-  return Setup(GetProfile(), &error_, base::Bind(
-      &MediaGalleriesStartMediaScanFunction::OnPreferencesInit, this));
-}
-
-void MediaGalleriesStartMediaScanFunction::OnPreferencesInit() {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  MediaGalleriesEventRouter* api = MediaGalleriesEventRouter::Get(GetProfile());
-  if (!api->ExtensionHasScanProgressListener(extension()->id())) {
-    error_ = kMissingEventListener;
-    SendResponse(false);
-    return;
-  }
-
-  media_scan_manager()->StartScan(GetProfile(), extension(), user_gesture());
-  SendResponse(true);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//                MediaGalleriesCancelMediaScanFunction                      //
-///////////////////////////////////////////////////////////////////////////////
-MediaGalleriesCancelMediaScanFunction::
-    ~MediaGalleriesCancelMediaScanFunction() {
-}
-
-bool MediaGalleriesCancelMediaScanFunction::RunAsync() {
-  media_galleries::UsageCount(media_galleries::CANCEL_MEDIA_SCAN);
-  if (!CheckScanPermission(extension(), &error_)) {
-    MediaGalleriesEventRouter::Get(GetProfile())
-        ->OnScanError(extension()->id());
-    return false;
-  }
-  return Setup(GetProfile(), &error_, base::Bind(
-      &MediaGalleriesCancelMediaScanFunction::OnPreferencesInit, this));
-}
-
-void MediaGalleriesCancelMediaScanFunction::OnPreferencesInit() {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  media_scan_manager()->CancelScan(GetProfile(), extension());
-  SendResponse(true);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//                MediaGalleriesAddScanResultsFunction                       //
-///////////////////////////////////////////////////////////////////////////////
-MediaGalleriesAddScanResultsFunction::~MediaGalleriesAddScanResultsFunction() {}
-
-bool MediaGalleriesAddScanResultsFunction::RunAsync() {
-  media_galleries::UsageCount(media_galleries::ADD_SCAN_RESULTS);
-  if (!CheckScanPermission(extension(), &error_)) {
-    // We don't fire a scan progress error here, as it would be unintuitive.
-    return false;
-  }
-  if (!user_gesture())
-    return false;
-
-  return Setup(GetProfile(), &error_, base::Bind(
-      &MediaGalleriesAddScanResultsFunction::OnPreferencesInit, this));
-}
-
-MediaGalleriesScanResultController*
-MediaGalleriesAddScanResultsFunction::MakeDialog(
-    content::WebContents* web_contents,
-    const extensions::Extension& extension,
-    const base::Closure& on_finish) {
-  // Controller will delete itself.
-  return new MediaGalleriesScanResultController(web_contents, extension,
-                                                on_finish);
-}
-
-void MediaGalleriesAddScanResultsFunction::OnPreferencesInit() {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  MediaGalleriesPreferences* preferences =
-      media_file_system_registry()->GetPreferences(GetProfile());
-  if (MediaGalleriesScanResultController::ScanResultCountForExtension(
-          preferences, extension()) == 0) {
-    GetAndReturnGalleries();
-    return;
-  }
-
-  WebContents* contents =
-      ChromeExtensionFunctionDetails(this).GetOriginWebContents();
-  if (!contents) {
-    SendResponse(false);
-    return;
-  }
-
-  base::Closure cb = base::Bind(
-      &MediaGalleriesAddScanResultsFunction::GetAndReturnGalleries, this);
-  MakeDialog(contents, *extension(), cb);
-}
-
-void MediaGalleriesAddScanResultsFunction::GetAndReturnGalleries() {
-  if (!render_frame_host()) {
-    ReturnGalleries(std::vector<MediaFileSystemInfo>());
-    return;
-  }
-  MediaFileSystemRegistry* registry = media_file_system_registry();
-  DCHECK(registry->GetPreferences(GetProfile())->IsInitialized());
-  registry->GetMediaFileSystemsForExtension(
-      GetSenderWebContents(), extension(),
-      base::Bind(&MediaGalleriesAddScanResultsFunction::ReturnGalleries, this));
-}
-
-void MediaGalleriesAddScanResultsFunction::ReturnGalleries(
-    const std::vector<MediaFileSystemInfo>& filesystems) {
-  scoped_ptr<base::ListValue> list(
-      ConstructFileSystemList(render_frame_host(), extension(), filesystems));
-  if (!list.get()) {
-    SendResponse(false);
-    return;
-  }
-
-  // The custom JS binding will use this list to create DOMFileSystem objects.
-  SetResult(list.release());
-  SendResponse(true);
-}
-
-///////////////////////////////////////////////////////////////////////////////
 //                 MediaGalleriesGetMetadataFunction                         //
 ///////////////////////////////////////////////////////////////////////////////
 MediaGalleriesGetMetadataFunction::~MediaGalleriesGetMetadataFunction() {}
 
 bool MediaGalleriesGetMetadataFunction::RunAsync() {
   media_galleries::UsageCount(media_galleries::GET_METADATA);
   std::string blob_uuid;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &blob_uuid));
 
   const base::Value* options_value = NULL;
@@ skipping 344 matching lines @@
       &MediaGalleriesRemoveAllGalleryWatchFunction::OnPreferencesInit, this));
   return true;
 }
 
 void MediaGalleriesRemoveAllGalleryWatchFunction::OnPreferencesInit() {
   gallery_watch_manager()->RemoveAllWatches(GetProfile(), extension_id());
   SendResponse(true);
 }
 
 }  // namespace extensions