Update content/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

content/browser/device_orientation/provider_impl.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.
 
 #include "content/browser/device_orientation/provider_impl.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 71 matching lines @@
   DCHECK(base::MessageLoop::current() == message_loop());
 
   if (factory != NULL) {
     // Try to use factory to create a fetcher that can provide this type of
     // data. If factory creates a fetcher that provides this type of data,
     // start polling.
     scoped_ptr<DataFetcher> fetcher(factory());
 
     if (fetcher) {
       scoped_refptr<const DeviceData> device_data(fetcher->GetDeviceData(type));
-      if (device_data != NULL) {
+      if (device_data.get() != NULL) {
         // Pass ownership of fetcher to provider_.
         data_fetcher_.swap(fetcher);
         last_device_data_map_[type] = device_data;
 
         // Notify observers.
         ScheduleDoNotify(device_data, type);
 
         // Start polling.
         ScheduleDoPoll();
         return;
@@ skipping 19 matching lines @@
   DCHECK(base::MessageLoop::current() == message_loop());
 
   // Poll the fetcher for each type of data.
   typedef std::set<DeviceData::Type>::const_iterator SetIterator;
   for (SetIterator i = polling_data_types_.begin();
        i != polling_data_types_.end(); ++i) {
     DeviceData::Type device_data_type = *i;
     scoped_refptr<const DeviceData> device_data(data_fetcher_->GetDeviceData(
         device_data_type));
 
-    if (device_data == NULL) {
+    if (device_data.get() == NULL) {
       LOG(ERROR) << "Failed to poll device data fetcher.";
       ScheduleDoNotify(NULL, device_data_type);
       continue;
     }
 
-    const DeviceData* old_data = last_device_data_map_[device_data_type];
+    const DeviceData* old_data = last_device_data_map_[device_data_type].get();
     if (old_data != NULL && !device_data->ShouldFireEvent(old_data))
       continue;
 
     // Update the last device data of this type and notify observers.
     last_device_data_map_[device_data_type] = device_data;
     ScheduleDoNotify(device_data, device_data_type);
   }
 
   ScheduleDoPoll();
 }
@@ skipping 41 matching lines @@
 void ProviderImpl::AddObserver(Observer* observer) {
   DCHECK(base::MessageLoop::current() == creator_loop_);
 
   DeviceData::Type type = observer->device_data_type();
 
   observers_.insert(observer);
   if (observers_.size() == 1)
     Start(type);
   else {
     // Notify observer of most recent notification if one exists.
-    const DeviceData *last_notification = last_notifications_map_[type];
+    const DeviceData* last_notification = last_notifications_map_[type].get();
     if (last_notification != NULL)
       observer->OnDeviceDataUpdate(last_notification, type);
   }
 
   ScheduleDoAddPollingDataType(type);
 }
 
 void ProviderImpl::RemoveObserver(Observer* observer) {
   DCHECK(base::MessageLoop::current() == creator_loop_);
 
@@ skipping 55 matching lines @@
   // Update last notification of this type.
   last_notifications_map_[device_data_type] = data;
 
   // Notify observers of this type of the new data.
   typedef std::set<Observer*>::const_iterator ConstIterator;
   for (ConstIterator i = observers_.begin(); i != observers_.end(); ++i) {
     if ((*i)->device_data_type() == device_data_type)
       (*i)->OnDeviceDataUpdate(data.get(), device_data_type);
   }
 
-  if (data == NULL) {
+  if (data.get() == NULL) {
     // Notify observers exactly once about failure to provide data.
     typedef std::set<Observer*>::iterator Iterator;
     Iterator i = observers_.begin();
     while (i != observers_.end()) {
       Iterator current = i++;
       if ((*current)->device_data_type() == device_data_type)
         observers_.erase(current);
     }
 
     if (observers_.empty())
       Stop();
   }
 }
 
 
 }  // namespace content