Remove implicit conversions from scoped_refptr to T* in content/

content/browser/device_sensors/data_fetcher_shared_memory_win.cc

 // Copyright 2014 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 "data_fetcher_shared_memory.h"
 
 #include <GuidDef.h>
 #include <InitGuid.h>
 #include <PortableDeviceTypes.h>
 #include <Sensors.h>
@@ skipping 292 matching lines @@
 
 bool DataFetcherSharedMemory::RegisterForSensor(
     REFSENSOR_TYPE_ID sensor_type,
     ISensor** sensor,
     scoped_refptr<SensorEventSink> event_sink) {
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return false;
 
   base::win::ScopedComPtr<ISensorManager> sensor_manager;
   HRESULT hr = sensor_manager.CreateInstance(CLSID_SensorManager);
-  if (FAILED(hr) || !sensor_manager)
+  if (FAILED(hr) || !sensor_manager.get())
     return false;
 
   base::win::ScopedComPtr<ISensorCollection> sensor_collection;
   hr = sensor_manager->GetSensorsByType(
       sensor_type, sensor_collection.Receive());
 
-  if (FAILED(hr) || !sensor_collection)
+  if (FAILED(hr) || !sensor_collection.get())
     return false;
 
   ULONG count = 0;
   hr = sensor_collection->GetCount(&count);
   if (FAILED(hr) || !count)
     return false;
 
   hr = sensor_collection->GetAt(0, sensor);
   if (FAILED(hr) || !(*sensor))
     return false;
 
   base::win::ScopedComPtr<IPortableDeviceValues> device_values;
   if (SUCCEEDED(device_values.CreateInstance(CLSID_PortableDeviceValues))) {
     if (SUCCEEDED(device_values->SetUnsignedIntegerValue(
         SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL,
         GetInterval().InMilliseconds()))) {
       base::win::ScopedComPtr<IPortableDeviceValues> return_values;
       (*sensor)->SetProperties(device_values.get(), return_values.Receive());
     }
   }
 
   base::win::ScopedComPtr<ISensorEvents> sensor_events;
   hr = event_sink->QueryInterface(
       __uuidof(ISensorEvents), sensor_events.ReceiveVoid());
-  if (FAILED(hr) || !sensor_events)
+  if (FAILED(hr) || !sensor_events.get())
     return false;
 
-  hr = (*sensor)->SetEventSink(sensor_events);
+  hr = (*sensor)->SetEventSink(sensor_events.get());
   if (FAILED(hr))
     return false;
 
   return true;
 }
 
 void DataFetcherSharedMemory::DisableSensors(ConsumerType consumer_type) {
   switch(consumer_type) {
     case CONSUMER_TYPE_ORIENTATION:
-      if (sensor_inclinometer_) {
+      if (sensor_inclinometer_.get()) {
         sensor_inclinometer_->SetEventSink(NULL);
         sensor_inclinometer_.Release();
       }
       break;
     case CONSUMER_TYPE_MOTION:
-      if (sensor_accelerometer_) {
+      if (sensor_accelerometer_.get()) {
         sensor_accelerometer_->SetEventSink(NULL);
         sensor_accelerometer_.Release();
       }
-      if (sensor_gyrometer_) {
+      if (sensor_gyrometer_.get()) {
         sensor_gyrometer_->SetEventSink(NULL);
         sensor_gyrometer_.Release();
       }
       break;
     default:
       NOTREACHED();
   }
 }
 
 void DataFetcherSharedMemory::SetBufferAvailableState(
@@ skipping 12 matching lines @@
         motion_buffer_->data.allAvailableSensorsAreActive = enabled;
         motion_buffer_->seqlock.WriteEnd();
       }
       break;
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace content