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

content/browser/device_orientation/provider_unittest.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 <map>
 #include <queue>
 
 #include "base/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "content/browser/device_orientation/data_fetcher.h"
@@ skipping 69 matching lines @@
 
   virtual ~MotionUpdateChecker() {}
 
   // From UpdateChecker.
   virtual void OnDeviceDataUpdate(const DeviceData* device_data,
       DeviceData::Type device_data_type) OVERRIDE {
     ASSERT_FALSE(expectations_queue_.empty());
     ASSERT_EQ(DeviceData::kTypeMotion, device_data_type);
 
     scoped_refptr<const Motion> motion(static_cast<const Motion*>(device_data));
-    if (motion == NULL)
+    if (motion.get() == NULL)
       motion = new Motion();
 
     scoped_refptr<const Motion> expected(static_cast<const Motion*>(
         (expectations_queue_.front().get())));
     expectations_queue_.pop();
 
     EXPECT_EQ(expected->can_provide_acceleration_x(),
               motion->can_provide_acceleration_x());
     EXPECT_EQ(expected->can_provide_acceleration_y(),
               motion->can_provide_acceleration_y());
@@ skipping 65 matching lines @@
   virtual ~OrientationUpdateChecker() {}
 
   // From UpdateChecker.
   virtual void OnDeviceDataUpdate(const DeviceData* device_data,
       DeviceData::Type device_data_type) OVERRIDE {
     ASSERT_FALSE(expectations_queue_.empty());
     ASSERT_EQ(DeviceData::kTypeOrientation, device_data_type);
 
     scoped_refptr<const Orientation> orientation(
         static_cast<const Orientation*>(device_data));
-    if (orientation == NULL)
+    if (orientation.get() == NULL)
       orientation = new Orientation();
 
     scoped_refptr<const Orientation> expected(static_cast<const Orientation*>(
         (expectations_queue_.front().get())));
     expectations_queue_.pop();
 
     EXPECT_EQ(expected->can_provide_alpha(), orientation->can_provide_alpha());
     EXPECT_EQ(expected->can_provide_beta(),  orientation->can_provide_beta());
     EXPECT_EQ(expected->can_provide_gamma(), orientation->can_provide_gamma());
     EXPECT_EQ(expected->can_provide_absolute(),
@@ skipping 24 matching lines @@
   }
 
   // From UpdateChecker.
   virtual void OnDeviceDataUpdate(const DeviceData* device_data,
       DeviceData::Type device_data_type) OVERRIDE {
     ASSERT_FALSE(expectations_queue_.empty());
     ASSERT_EQ(DeviceData::kTypeTest, device_data_type);
 
     scoped_refptr<const TestData> test_data(
         static_cast<const TestData*>(device_data));
-    if (test_data == NULL)
+    if (test_data.get() == NULL)
       test_data = new TestData();
 
     scoped_refptr<const TestData> expected(static_cast<const TestData*>(
         (expectations_queue_.front().get())));
     expectations_queue_.pop();
 
     EXPECT_EQ(expected->value(), test_data->value());
 
     --(*expectations_count_ptr_);
 
@@ skipping 48 matching lines @@
    public:
     explicit MockDataFetcher(MockDeviceDataFactory* device_data_factory)
         : device_data_factory_(device_data_factory) { }
 
     // From DataFetcher. Called by the Provider.
     virtual const DeviceData* GetDeviceData(
         DeviceData::Type device_data_type) OVERRIDE {
       base::AutoLock auto_lock(device_data_factory_->lock_);
       if (device_data_factory_->is_failing_)
         return NULL;
-      return device_data_factory_->device_data_map_[device_data_type];
+      return device_data_factory_->device_data_map_[device_data_type].get();
     }
 
    private:
     scoped_refptr<MockDeviceDataFactory> device_data_factory_;
   };
 
   static MockDeviceDataFactory* instance_;
   std::map<DeviceData::Type, scoped_refptr<const DeviceData> > device_data_map_;
   bool is_failing_;
   base::Lock lock_;
@@ skipping 14 matching lines @@
     EXPECT_FALSE(Provider::GetInstanceForTests());
 
     // Clean up in any case, so as to not break subsequent test.
     Provider::SetInstanceForTests(NULL);
   }
 
   // Initialize the test fixture with a ProviderImpl that uses the
   // DataFetcherFactory factory.
   void Init(ProviderImpl::DataFetcherFactory factory) {
     provider_ = new ProviderImpl(factory);
-    Provider::SetInstanceForTests(provider_);
+    Provider::SetInstanceForTests(provider_.get());
   }
 
  protected:
   // Number of pending expectations.
   int pending_expectations_;
 
   // Provider instance under test.
   scoped_refptr<Provider> provider_;
 
   // Message loop for the test thread.
@@ skipping 41 matching lines @@
   MockDeviceDataFactory::SetCurInstance(device_data_factory.get());
   Init(MockDeviceDataFactory::CreateDataFetcher);
   scoped_refptr<Orientation> test_orientation(new Orientation());
   test_orientation->set_alpha(1);
   test_orientation->set_beta(2);
   test_orientation->set_gamma(3);
   test_orientation->set_absolute(true);
 
   scoped_ptr<OrientationUpdateChecker> checker(
       new OrientationUpdateChecker(&pending_expectations_));
-  checker->AddExpectation(test_orientation);
-  device_data_factory->SetDeviceData(test_orientation,
-      DeviceData::kTypeOrientation);
+  checker->AddExpectation(test_orientation.get());
+  device_data_factory->SetDeviceData(test_orientation.get(),
+                                     DeviceData::kTypeOrientation);
   provider_->AddObserver(checker.get());
   base::MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker.get());
   MockDeviceDataFactory::SetCurInstance(NULL);
 }
 
 // Tests multiple observers observing the same type of data.
 TEST_F(DeviceOrientationProviderTest, MultipleObserversPushTest) {
   scoped_refptr<MockDeviceDataFactory> device_data_factory(
@@ skipping 18 matching lines @@
   test_orientations[2]->set_gamma(9);
   // can't provide absolute
 
   scoped_ptr<OrientationUpdateChecker> checker_a(
       new OrientationUpdateChecker(&pending_expectations_));
   scoped_ptr<OrientationUpdateChecker> checker_b(
       new OrientationUpdateChecker(&pending_expectations_));
   scoped_ptr<OrientationUpdateChecker> checker_c(
       new OrientationUpdateChecker(&pending_expectations_));
 
-  checker_a->AddExpectation(test_orientations[0]);
-  device_data_factory->SetDeviceData(test_orientations[0],
-      DeviceData::kTypeOrientation);
+  checker_a->AddExpectation(test_orientations[0].get());
+  device_data_factory->SetDeviceData(test_orientations[0].get(),
+                                     DeviceData::kTypeOrientation);
   provider_->AddObserver(checker_a.get());
   base::MessageLoop::current()->Run();
 
-  checker_a->AddExpectation(test_orientations[1]);
-  checker_b->AddExpectation(test_orientations[0]);
-  checker_b->AddExpectation(test_orientations[1]);
-  device_data_factory->SetDeviceData(test_orientations[1],
-      DeviceData::kTypeOrientation);
+  checker_a->AddExpectation(test_orientations[1].get());
+  checker_b->AddExpectation(test_orientations[0].get());
+  checker_b->AddExpectation(test_orientations[1].get());
+  device_data_factory->SetDeviceData(test_orientations[1].get(),
+                                     DeviceData::kTypeOrientation);
   provider_->AddObserver(checker_b.get());
   base::MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker_a.get());
-  checker_b->AddExpectation(test_orientations[2]);
-  checker_c->AddExpectation(test_orientations[1]);
-  checker_c->AddExpectation(test_orientations[2]);
-  device_data_factory->SetDeviceData(test_orientations[2],
-      DeviceData::kTypeOrientation);
+  checker_b->AddExpectation(test_orientations[2].get());
+  checker_c->AddExpectation(test_orientations[1].get());
+  checker_c->AddExpectation(test_orientations[2].get());
+  device_data_factory->SetDeviceData(test_orientations[2].get(),
+                                     DeviceData::kTypeOrientation);
   provider_->AddObserver(checker_c.get());
   base::MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker_b.get());
   provider_->RemoveObserver(checker_c.get());
   MockDeviceDataFactory::SetCurInstance(NULL);
 }
 
 // Test for when the fetcher cannot provide the first type of data but can
 // provide the second type.
@@ skipping 12 matching lines @@
   scoped_refptr<Orientation> test_orientation(new Orientation());
   test_orientation->set_alpha(1);
   test_orientation->set_beta(2);
   test_orientation->set_gamma(3);
   test_orientation->set_absolute(true);
 
   test_data_checker->AddExpectation(new TestData());
   provider_->AddObserver(test_data_checker.get());
   base::MessageLoop::current()->Run();
 
-  orientation_checker->AddExpectation(test_orientation);
-  device_data_factory->SetDeviceData(test_orientation,
-      DeviceData::kTypeOrientation);
+  orientation_checker->AddExpectation(test_orientation.get());
+  device_data_factory->SetDeviceData(test_orientation.get(),
+                                     DeviceData::kTypeOrientation);
   provider_->AddObserver(orientation_checker.get());
   base::MessageLoop::current()->Run();
 
   provider_->RemoveObserver(test_data_checker.get());
   provider_->RemoveObserver(orientation_checker.get());
   MockDeviceDataFactory::SetCurInstance(NULL);
 }
 
 #if defined(OS_LINUX) || defined(OS_WIN)
 // Flakily DCHECKs on Linux. See crbug.com/104950.
@@ skipping 14 matching lines @@
   test_orientation->set_absolute(true);
 
   scoped_refptr<Orientation> test_orientation2(new Orientation());
   test_orientation2->set_alpha(4);
   test_orientation2->set_beta(5);
   test_orientation2->set_gamma(6);
   test_orientation2->set_absolute(false);
 
   scoped_ptr<OrientationUpdateChecker> checker(
       new OrientationUpdateChecker(&pending_expectations_));
-  checker->AddExpectation(test_orientation);
-  device_data_factory->SetDeviceData(test_orientation,
-      DeviceData::kTypeOrientation);
+  checker->AddExpectation(test_orientation.get());
+  device_data_factory->SetDeviceData(test_orientation.get(),
+                                     DeviceData::kTypeOrientation);
   provider_->AddObserver(checker.get());
   base::MessageLoop::current()->Run();
 
-  checker->AddExpectation(test_orientation2);
-  device_data_factory->SetDeviceData(test_orientation2,
-      DeviceData::kTypeOrientation);
+  checker->AddExpectation(test_orientation2.get());
+  device_data_factory->SetDeviceData(test_orientation2.get(),
+                                     DeviceData::kTypeOrientation);
   base::MessageLoop::current()->Run();
 
   MockDeviceDataFactory::SetCurInstance(NULL);
 
   // Note that checker is not removed. This should not be a problem.
 }
 
 #if defined(OS_WIN)
 // FLAKY on Win. See crbug.com/104950.
 #define MAYBE_StartFailing DISABLED_StartFailing
 #else
 #define MAYBE_StartFailing StartFailing
 #endif
 TEST_F(DeviceOrientationProviderTest, MAYBE_StartFailing) {
   scoped_refptr<MockDeviceDataFactory> device_data_factory(
       new MockDeviceDataFactory());
   MockDeviceDataFactory::SetCurInstance(device_data_factory.get());
   Init(MockDeviceDataFactory::CreateDataFetcher);
   scoped_refptr<Orientation> test_orientation(new Orientation());
   test_orientation->set_alpha(1);
   test_orientation->set_beta(2);
   test_orientation->set_gamma(3);
   test_orientation->set_absolute(true);
 
   scoped_ptr<OrientationUpdateChecker> checker_a(new OrientationUpdateChecker(
       &pending_expectations_));
   scoped_ptr<OrientationUpdateChecker> checker_b(new OrientationUpdateChecker(
       &pending_expectations_));
 
-  device_data_factory->SetDeviceData(test_orientation,
-      DeviceData::kTypeOrientation);
-  checker_a->AddExpectation(test_orientation);
+  device_data_factory->SetDeviceData(test_orientation.get(),
+                                     DeviceData::kTypeOrientation);
+  checker_a->AddExpectation(test_orientation.get());
   provider_->AddObserver(checker_a.get());
   base::MessageLoop::current()->Run();
 
   checker_a->AddExpectation(new Orientation());
   device_data_factory->SetFailing(true);
   base::MessageLoop::current()->Run();
 
   checker_b->AddExpectation(new Orientation());
   provider_->AddObserver(checker_b.get());
   base::MessageLoop::current()->Run();
@@ skipping 19 matching lines @@
   test_orientation2->set_alpha(4);
   test_orientation2->set_beta(5);
   test_orientation2->set_gamma(6);
   test_orientation2->set_absolute(false);
 
   scoped_ptr<OrientationUpdateChecker> checker_a(new OrientationUpdateChecker(
       &pending_expectations_));
   scoped_ptr<OrientationUpdateChecker> checker_b(new OrientationUpdateChecker(
       &pending_expectations_));
 
-  checker_a->AddExpectation(test_orientation);
-  device_data_factory->SetDeviceData(test_orientation,
-      DeviceData::kTypeOrientation);
+  checker_a->AddExpectation(test_orientation.get());
+  device_data_factory->SetDeviceData(test_orientation.get(),
+                                     DeviceData::kTypeOrientation);
   provider_->AddObserver(checker_a.get());
   base::MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker_a.get()); // This stops the Provider.
 
-  checker_b->AddExpectation(test_orientation2);
-  device_data_factory->SetDeviceData(test_orientation2,
-      DeviceData::kTypeOrientation);
+  checker_b->AddExpectation(test_orientation2.get());
+  device_data_factory->SetDeviceData(test_orientation2.get(),
+                                     DeviceData::kTypeOrientation);
   provider_->AddObserver(checker_b.get());
   base::MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker_b.get());
   MockDeviceDataFactory::SetCurInstance(NULL);
 }
 
 // Tests that Motion events always fire, even if the motion is unchanged.
 TEST_F(DeviceOrientationProviderTest, FLAKY_MotionAlwaysFires) {
   scoped_refptr<MockDeviceDataFactory> device_data_factory(
       new MockDeviceDataFactory());
   MockDeviceDataFactory::SetCurInstance(device_data_factory.get());
   Init(MockDeviceDataFactory::CreateDataFetcher);
 
   scoped_refptr<Motion> test_motion(new Motion());
   test_motion->set_acceleration_x(1);
   test_motion->set_acceleration_y(2);
   test_motion->set_acceleration_z(3);
   test_motion->set_acceleration_including_gravity_x(4);
   test_motion->set_acceleration_including_gravity_y(5);
   test_motion->set_acceleration_including_gravity_z(6);
   test_motion->set_rotation_rate_alpha(7);
   test_motion->set_rotation_rate_beta(8);
   test_motion->set_rotation_rate_gamma(9);
   test_motion->set_interval(10);
 
   scoped_ptr<MotionUpdateChecker> checker(new MotionUpdateChecker(
       &pending_expectations_));
 
-  device_data_factory->SetDeviceData(test_motion, DeviceData::kTypeMotion);
-  checker->AddExpectation(test_motion);
+  device_data_factory->SetDeviceData(test_motion.get(),
+                                     DeviceData::kTypeMotion);
+  checker->AddExpectation(test_motion.get());
   provider_->AddObserver(checker.get());
   base::MessageLoop::current()->Run();
 
   // The observer should receive the same motion again.
-  device_data_factory->SetDeviceData(test_motion, DeviceData::kTypeMotion);
-  checker->AddExpectation(test_motion);
+  device_data_factory->SetDeviceData(test_motion.get(),
+                                     DeviceData::kTypeMotion);
+  checker->AddExpectation(test_motion.get());
   base::MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker.get());
   MockDeviceDataFactory::SetCurInstance(NULL);
 }
 
 // Tests that Orientation events only fire if the change is significant.
 TEST_F(DeviceOrientationProviderTest, OrientationSignificantlyDifferent) {
   scoped_refptr<MockDeviceDataFactory> device_data_factory(
       new MockDeviceDataFactory());
@@ skipping 22 matching lines @@
   third_orientation->set_alpha(kAlpha + kSignificantDifference);
   third_orientation->set_beta(kBeta + kSignificantDifference);
   third_orientation->set_gamma(kGamma + kSignificantDifference);
   // can't provide absolute
 
   scoped_ptr<OrientationUpdateChecker> checker_a(new OrientationUpdateChecker(
       &pending_expectations_));
   scoped_ptr<OrientationUpdateChecker> checker_b(new OrientationUpdateChecker(
       &pending_expectations_));
 
-  device_data_factory->SetDeviceData(first_orientation,
-      DeviceData::kTypeOrientation);
-  checker_a->AddExpectation(first_orientation);
+  device_data_factory->SetDeviceData(first_orientation.get(),
+                                     DeviceData::kTypeOrientation);
+  checker_a->AddExpectation(first_orientation.get());
   provider_->AddObserver(checker_a.get());
   base::MessageLoop::current()->Run();
 
   // The observers should not see this insignificantly different orientation.
-  device_data_factory->SetDeviceData(second_orientation,
-      DeviceData::kTypeOrientation);
-  checker_b->AddExpectation(first_orientation);
+  device_data_factory->SetDeviceData(second_orientation.get(),
+                                     DeviceData::kTypeOrientation);
+  checker_b->AddExpectation(first_orientation.get());
   provider_->AddObserver(checker_b.get());
   base::MessageLoop::current()->Run();
 
-  device_data_factory->SetDeviceData(third_orientation,
-      DeviceData::kTypeOrientation);
-  checker_a->AddExpectation(third_orientation);
-  checker_b->AddExpectation(third_orientation);
+  device_data_factory->SetDeviceData(third_orientation.get(),
+                                     DeviceData::kTypeOrientation);
+  checker_a->AddExpectation(third_orientation.get());
+  checker_b->AddExpectation(third_orientation.get());
   base::MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker_a.get());
   provider_->RemoveObserver(checker_b.get());
   MockDeviceDataFactory::SetCurInstance(NULL);
 }
 
 }  // namespace
 
 }  // namespace content