Replace DCHECK(BrowserThread::CurrentlyOn) with DCHECK_CURRENTLY_ON in extensions.

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 244 matching lines @@
   Callback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SelectDirectoryDialog);
 };
 
 }  // namespace
 
 MediaGalleriesEventRouter::MediaGalleriesEventRouter(
     content::BrowserContext* context)
     : profile_(Profile::FromBrowserContext(context)), weak_ptr_factory_(this) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(profile_);
   media_scan_manager()->AddObserver(profile_, this);
 }
 
 MediaGalleriesEventRouter::~MediaGalleriesEventRouter() {
 }
 
 void MediaGalleriesEventRouter::Shutdown() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   weak_ptr_factory_.InvalidateWeakPtrs();
   media_scan_manager()->RemoveObserver(profile_);
   media_scan_manager()->CancelScansForProfile(profile_);
 }
 
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<MediaGalleriesEventRouter> > g_factory =
     LAZY_INSTANCE_INITIALIZER;
 
 // static
@@ skipping 61 matching lines @@
   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));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   EventRouter* router =
       extensions::ExtensionSystem::Get(profile_)->event_router();
   if (!router->ExtensionHasEventListener(extension_id, event_name))
     return;
 
   scoped_ptr<extensions::Event> event(
       new extensions::Event(event_name, event_args.Pass()));
   router->DispatchEventToExtension(extension_id, event.Pass());
 }
 
@@ skipping 283 matching lines @@
   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));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MediaGalleriesEventRouter* api = MediaGalleriesEventRouter::Get(GetProfile());
   if (!api->ExtensionHasScanProgressListener(GetExtension()->id())) {
     error_ = kMissingEventListener;
     SendResponse(false);
     return;
   }
 
   media_scan_manager()->StartScan(GetProfile(), GetExtension(), user_gesture());
   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));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   media_scan_manager()->CancelScan(GetProfile(), GetExtension());
   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.
@@ skipping 10 matching lines @@
 MediaGalleriesAddScanResultsFunction::MakeDialog(
     content::WebContents* web_contents,
     const extensions::Extension& extension,
     const base::Closure& on_finish) {
   // Controller will delete itself.
   return new MediaGalleriesScanResultDialogController(web_contents, extension,
                                                       on_finish);
 }
 
 void MediaGalleriesAddScanResultsFunction::OnPreferencesInit() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   const Extension* extension = GetExtension();
   MediaGalleriesPreferences* preferences =
       media_file_system_registry()->GetPreferences(GetProfile());
   if (MediaGalleriesScanResultDialogController::ScanResultCountForExtension(
           preferences, extension) == 0) {
     GetAndReturnGalleries();
     return;
   }
 
   WebContents* contents =
@@ skipping 52 matching lines @@
   bool mime_type_only = options->metadata_type ==
       MediaGalleries::GET_METADATA_TYPE_MIMETYPEONLY;
 
   return Setup(GetProfile(), &error_, base::Bind(
       &MediaGalleriesGetMetadataFunction::OnPreferencesInit, this,
       mime_type_only, blob_uuid));
 }
 
 void MediaGalleriesGetMetadataFunction::OnPreferencesInit(
     bool mime_type_only, const std::string& blob_uuid) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // BlobReader is self-deleting.
   BlobReader* reader = new BlobReader(
       GetProfile(),
       blob_uuid,
       base::Bind(&MediaGalleriesGetMetadataFunction::SniffMimeType, this,
                  mime_type_only, blob_uuid));
   reader->SetByteRange(0, net::kMaxBytesToSniff);
   reader->Start();
 }
 
 void MediaGalleriesGetMetadataFunction::SniffMimeType(
     bool mime_type_only, const std::string& blob_uuid,
     scoped_ptr<std::string> blob_header, int64 total_blob_length) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   std::string mime_type;
   bool mime_type_sniffed = net::SniffMimeTypeFromLocalData(
       blob_header->c_str(), blob_header->size(), &mime_type);
 
   if (!mime_type_sniffed) {
     SendResponse(false);
     return;
   }
 
@@ skipping 17 matching lines @@
   if (!parse_success) {
     SendResponse(false);
     return;
   }
 
   SetResult(metadata_dictionary->DeepCopy());
   SendResponse(true);
 }
 
 }  // namespace extensions