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

chrome/browser/extensions/api/location/location_manager.cc

 // Copyright (c) 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/extensions/api/location/location_manager.h"
 
 #include <math.h>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 195 matching lines @@
 LocationRequest::LocationRequest(
     const base::WeakPtr<LocationManager>& location_manager,
     const std::string& extension_id,
     const std::string& request_name,
     const double* distance_update_threshold_meters,
     const double* time_between_updates_ms)
     : request_name_(request_name),
       extension_id_(extension_id),
       location_manager_(location_manager) {
   // TODO(vadimt): use request_info.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (time_between_updates_ms) {
     update_policies_.push_back(
         new updatepolicy::TimeBasedUpdatePolicy(
             *time_between_updates_ms));
   }
 
   if (distance_update_threshold_meters) {
     update_policies_.push_back(
         new updatepolicy::DistanceBasedUpdatePolicy(
               *distance_update_threshold_meters));
   }
 }
 
 void LocationRequest::Initialize() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   callback_ = base::Bind(&LocationRequest::OnLocationUpdate,
                          base::Unretained(this));
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&LocationRequest::AddObserverOnIOThread,
                  this));
 }
 
 void LocationRequest::GrantPermission() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   content::GeolocationProvider::GetInstance()->UserDidOptIntoLocationServices();
 }
 
 LocationRequest::~LocationRequest() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   content::GeolocationProvider::GetInstance()->RemoveLocationUpdateCallback(
       callback_);
 }
 
 void LocationRequest::AddObserverOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(vadimt): This can get a location cached by GeolocationProvider,
   // contrary to the API definition which says that creating a location watch
   // will get new location.
   content::GeolocationProvider::GetInstance()->AddLocationUpdateCallback(
       callback_, true);
 }
 
 void LocationRequest::OnLocationUpdate(const content::Geoposition& position) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (ShouldSendUpdate(position)) {
     OnPositionReported(position);
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&LocationManager::SendLocationUpdate,
                    location_manager_,
                    extension_id_,
                    request_name_,
                    position));
   }
 }
 
 bool LocationRequest::ShouldSendUpdate(const content::Geoposition& position) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (UpdatePolicyVector::iterator it = update_policies_.begin();
        it != update_policies_.end();
        ++it) {
     if (!((*it)->ShouldSendUpdate(position))) {
       return false;
     }
   }
   return true;
 }
 
 void LocationRequest::OnPositionReported(const content::Geoposition& position) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (UpdatePolicyVector::iterator it = update_policies_.begin();
        it != update_policies_.end();
        ++it) {
     (*it)->OnPositionReported(position);
   }
 }
 
 LocationManager::LocationManager(content::BrowserContext* context)
     : profile_(Profile::FromBrowserContext(context)) {
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
                  content::Source<Profile>(profile_));
 }
 
 void LocationManager::AddLocationRequest(
     const std::string& extension_id,
     const std::string& request_name,
     const double* distance_update_threshold_meters,
     const double* time_between_updates_ms) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // TODO(vadimt): Consider resuming requests after restarting the browser.
 
   // Override any old request with the same name.
   RemoveLocationRequest(extension_id, request_name);
 
   LocationRequestPointer location_request =
       new LocationRequest(AsWeakPtr(),
                           extension_id,
                           request_name,
                           distance_update_threshold_meters,
                           time_between_updates_ms);
   location_request->Initialize();
   location_requests_.insert(
       LocationRequestMap::value_type(extension_id, location_request));
 }
 
 void LocationManager::RemoveLocationRequest(const std::string& extension_id,
                                             const std::string& name) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::pair<LocationRequestMap::iterator, LocationRequestMap::iterator>
       extension_range = location_requests_.equal_range(extension_id);
 
   for (LocationRequestMap::iterator it = extension_range.first;
        it != extension_range.second;
        ++it) {
     if (it->second->request_name() == name) {
       location_requests_.erase(it);
       return;
@@ skipping 19 matching lines @@
   if (position.heading >= 0. && position.heading <= 360.)
     coordinates->heading.reset(new double(position.heading));
   if (position.speed >= 0.)
     coordinates->speed.reset(new double(position.speed));
 }
 
 void LocationManager::SendLocationUpdate(
     const std::string& extension_id,
     const std::string& request_name,
     const content::Geoposition& position) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
   std::string event_name;
 
   if (position.Validate() &&
       position.error_code == content::Geoposition::ERROR_CODE_NONE) {
     // Set data for onLocationUpdate event.
     location::Location location;
     location.name = request_name;
     GeopositionToApiCoordinates(position, &location.coords);
@@ skipping 10 matching lines @@
 
   scoped_ptr<Event> event(new Event(event_name, args.Pass()));
 
   ExtensionSystem::Get(profile_)->event_router()->
       DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void LocationManager::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       // Grants permission to use geolocation once an extension with "location"
       // permission is loaded.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
 
       if (extension->HasAPIPermission(APIPermission::kLocation)) {
           BrowserThread::PostTask(
@@ skipping 24 matching lines @@
 LocationManager::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
  // static
 LocationManager* LocationManager::Get(content::BrowserContext* context) {
   return BrowserContextKeyedAPIFactory<LocationManager>::Get(context);
 }
 
 }  // namespace extensions