Media Galleries API Scanning: Add Scan Permission and basic test.

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 <set>
 #include <string>
@@ skipping 46 matching lines @@
 
 namespace MediaGalleries = api::media_galleries;
 namespace GetMediaFileSystems = MediaGalleries::GetMediaFileSystems;
 
 namespace {
 
 const char kDisallowedByPolicy[] =
     "Media Galleries API is disallowed by policy: ";
 const char kMissingEventListener[] =
     "Missing event listener registration.";
+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";
 
 MediaFileSystemRegistry* media_file_system_registry() {
   return g_browser_process->media_file_system_registry();
@@ skipping 97 matching lines @@
         if (has_copy_to_permission) {
           policy->GrantCopyIntoFileSystem(child_id, filesystems[i].fsid);
         }
       }
     }
   }
 
   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 = PermissionsData::CheckAPIPermissionWithParam(
+      extension, 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 114 matching lines @@
   details.gallery_count.reset(new int(gallery_count));
   details.image_count.reset(new int(image_count));
   details.audio_count.reset(new int(audio_count));
   details.video_count.reset(new int(video_count));
   DispatchEventToExtension(
       extension_id,
       MediaGalleries::OnScanProgress::kEventName,
       MediaGalleries::OnScanProgress::Create(details).Pass());
 }
 
+void MediaGalleriesEventRouter::OnScanError(
+    const std::string& extension_id) {
+  MediaGalleries::ScanProgressDetails details;
+  details.type = MediaGalleries::SCAN_PROGRESS_TYPE_ERROR;
+  DispatchEventToExtension(
+      extension_id,
+      MediaGalleries::OnScanProgress::kEventName,
+      MediaGalleries::OnScanProgress::Create(details).Pass());
+}
+
 void MediaGalleriesEventRouter::DispatchEventToExtension(
     const std::string& extension_id,
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   EventRouter* router =
       extensions::ExtensionSystem::Get(profile_)->event_router();
   if (!router->ExtensionHasEventListener(extension_id, event_name))
     return;
 
@@ skipping 270 matching lines @@
   MediaFileSystemRegistry* registry = media_file_system_registry();
   DCHECK(registry->GetPreferences(GetProfile())->IsInitialized());
   registry->GetMediaFileSystemsForExtension(
       render_view_host(), GetExtension(), cb);
 }
 
 MediaGalleriesStartMediaScanFunction::~MediaGalleriesStartMediaScanFunction() {}
 
 bool MediaGalleriesStartMediaScanFunction::RunImpl() {
   media_galleries::UsageCount(media_galleries::START_MEDIA_SCAN);
+  if (!CheckScanPermission(GetExtension(), &error_)) {
+    MediaGalleriesEventRouter::Get(GetProfile())->OnScanError(
+        GetExtension()->id());
+    return false;
+  }
   return Setup(GetProfile(), &error_, base::Bind(
       &MediaGalleriesStartMediaScanFunction::OnPreferencesInit, this));
 }
 
 void MediaGalleriesStartMediaScanFunction::OnPreferencesInit() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   MediaGalleriesEventRouter* api = MediaGalleriesEventRouter::Get(GetProfile());
   if (!api->ExtensionHasScanProgressListener(GetExtension()->id())) {
     error_ = kMissingEventListener;
     SendResponse(false);
     return;
   }
 
   media_scan_manager()->StartScan(GetProfile(), GetExtension()->id());
   SendResponse(true);
 }
 
 MediaGalleriesCancelMediaScanFunction::
     ~MediaGalleriesCancelMediaScanFunction() {
 }
 
 bool MediaGalleriesCancelMediaScanFunction::RunImpl() {
   media_galleries::UsageCount(media_galleries::CANCEL_MEDIA_SCAN);
+  if (!CheckScanPermission(GetExtension(), &error_)) {
+    MediaGalleriesEventRouter::Get(GetProfile())->OnScanError(
+        GetExtension()->id());
+    return false;
+  }
   return Setup(GetProfile(), &error_, base::Bind(
       &MediaGalleriesCancelMediaScanFunction::OnPreferencesInit, this));
 }
 
 void MediaGalleriesCancelMediaScanFunction::OnPreferencesInit() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   media_scan_manager()->CancelScan(GetProfile(), GetExtension()->id());
   SendResponse(true);
 }
 
 MediaGalleriesAddScanResultsFunction::~MediaGalleriesAddScanResultsFunction() {}
 
 bool MediaGalleriesAddScanResultsFunction::RunImpl() {
   media_galleries::UsageCount(media_galleries::ADD_SCAN_RESULTS);
+  if (!CheckScanPermission(GetExtension(), &error_)) {
+    // We don't fire a scan progress error here, as it would be unintuitive.
+    return false;
+  }
   return Setup(GetProfile(), &error_, base::Bind(
       &MediaGalleriesAddScanResultsFunction::OnPreferencesInit, this));
 }
 
 void MediaGalleriesAddScanResultsFunction::OnPreferencesInit() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   const Extension* extension = GetExtension();
   WebContents* contents =
       GetWebContents(render_view_host(), GetProfile(), extension->id());
   if (!contents) {
@@ skipping 83 matching lines @@
   if (mime_type_sniffed)
     metadata.mime_type = mime_type;
 
   // TODO(tommycli): Kick off SafeMediaMetadataParser if |mime_type_only| false.
 
   SetResult(metadata.ToValue().release());
   SendResponse(true);
 }
 
 }  // namespace extensions