content: Use base::MessageLoop.

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 132 matching lines @@
     if (expected->can_provide_rotation_rate_gamma())
       EXPECT_EQ(expected->rotation_rate_gamma(),
                 motion->rotation_rate_gamma());
 
     if (expected->can_provide_interval())
       EXPECT_EQ(expected->interval(), motion->interval());
 
     --(*expectations_count_ptr_);
 
     if (*expectations_count_ptr_ == 0) {
-      MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+      base::MessageLoop::current()->PostTask(FROM_HERE,
+                                             base::MessageLoop::QuitClosure());
     }
   }
 };
 
 // Class for checking expectations on orientation updates from the Provider.
 class OrientationUpdateChecker : public UpdateChecker {
  public:
   explicit OrientationUpdateChecker(int* expectations_count_ptr)
       : UpdateChecker(DeviceData::kTypeOrientation, expectations_count_ptr) {
   }
@@ skipping 25 matching lines @@
     if (expected->can_provide_beta())
       EXPECT_EQ(expected->beta(), orientation->beta());
     if (expected->can_provide_gamma())
       EXPECT_EQ(expected->gamma(), orientation->gamma());
     if (expected->can_provide_absolute())
       EXPECT_EQ(expected->absolute(), orientation->absolute());
 
     --(*expectations_count_ptr_);
 
     if (*expectations_count_ptr_ == 0) {
-      MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+      base::MessageLoop::current()->PostTask(FROM_HERE,
+                                             base::MessageLoop::QuitClosure());
     }
   }
 };
 
 // Class for checking expectations on test_data updates from the Provider.
 class TestDataUpdateChecker : public UpdateChecker {
  public:
   explicit TestDataUpdateChecker(int* expectations_count_ptr)
       : UpdateChecker(DeviceData::kTypeTest, expectations_count_ptr) {
   }
@@ skipping 11 matching lines @@
 
     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_);
 
     if (*expectations_count_ptr_ == 0) {
-      MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+      base::MessageLoop::current()->PostTask(FROM_HERE,
+                                             base::MessageLoop::QuitClosure());
     }
   }
 };
 
 // Class for injecting test device data into the Provider.
 class MockDeviceDataFactory
     : public base::RefCountedThreadSafe<MockDeviceDataFactory> {
  public:
   MockDeviceDataFactory()
       : is_failing_(false) {
@@ skipping 81 matching lines @@
   }
 
  protected:
   // Number of pending expectations.
   int pending_expectations_;
 
   // Provider instance under test.
   scoped_refptr<Provider> provider_;
 
   // Message loop for the test thread.
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
 };
 
 TEST_F(DeviceOrientationProviderTest, FailingTest) {
   scoped_refptr<MockDeviceDataFactory> device_data_factory(
       new MockDeviceDataFactory());
   MockDeviceDataFactory::SetCurInstance(device_data_factory.get());
   Init(MockDeviceDataFactory::CreateDataFetcher);
 
   scoped_ptr<OrientationUpdateChecker> checker_a(
       new OrientationUpdateChecker(&pending_expectations_));
   scoped_ptr<OrientationUpdateChecker> checker_b(
       new OrientationUpdateChecker(&pending_expectations_));
 
   checker_a->AddExpectation(new Orientation());
   provider_->AddObserver(checker_a.get());
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   checker_b->AddExpectation(new Orientation());
   provider_->AddObserver(checker_b.get());
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   MockDeviceDataFactory::SetCurInstance(NULL);
 }
 
 TEST_F(DeviceOrientationProviderTest, ProviderIsSingleton) {
   scoped_refptr<MockDeviceDataFactory> device_data_factory(
       new MockDeviceDataFactory());
   MockDeviceDataFactory::SetCurInstance(device_data_factory.get());
   Init(MockDeviceDataFactory::CreateDataFetcher);
 
@@ skipping 14 matching lines @@
   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);
   provider_->AddObserver(checker.get());
-  MessageLoop::current()->Run();
+  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(
       new MockDeviceDataFactory());
   MockDeviceDataFactory::SetCurInstance(device_data_factory.get());
@@ skipping 20 matching lines @@
       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);
   provider_->AddObserver(checker_a.get());
-  MessageLoop::current()->Run();
+  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);
   provider_->AddObserver(checker_b.get());
-  MessageLoop::current()->Run();
+  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);
   provider_->AddObserver(checker_c.get());
-  MessageLoop::current()->Run();
+  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.
 TEST_F(DeviceOrientationProviderTest, FailingFirstDataTypeTest) {
 
   scoped_refptr<MockDeviceDataFactory> device_data_factory(
       new MockDeviceDataFactory());
   MockDeviceDataFactory::SetCurInstance(device_data_factory.get());
   Init(MockDeviceDataFactory::CreateDataFetcher);
 
   scoped_ptr<TestDataUpdateChecker> test_data_checker(
       new TestDataUpdateChecker(&pending_expectations_));
   scoped_ptr<OrientationUpdateChecker> orientation_checker(
       new OrientationUpdateChecker(&pending_expectations_));
 
   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());
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   orientation_checker->AddExpectation(test_orientation);
   device_data_factory->SetDeviceData(test_orientation,
       DeviceData::kTypeOrientation);
   provider_->AddObserver(orientation_checker.get());
-  MessageLoop::current()->Run();
+  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.
 // FLAKY on Win. See crbug.com/104950.
 #define MAYBE_ObserverNotRemoved DISABLED_ObserverNotRemoved
@@ skipping 16 matching lines @@
   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);
   provider_->AddObserver(checker.get());
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   checker->AddExpectation(test_orientation2);
   device_data_factory->SetDeviceData(test_orientation2,
       DeviceData::kTypeOrientation);
-  MessageLoop::current()->Run();
+  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
@@ skipping 12 matching lines @@
 
   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);
   provider_->AddObserver(checker_a.get());
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   checker_a->AddExpectation(new Orientation());
   device_data_factory->SetFailing(true);
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   checker_b->AddExpectation(new Orientation());
   provider_->AddObserver(checker_b.get());
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker_a.get());
   provider_->RemoveObserver(checker_b.get());
   MockDeviceDataFactory::SetCurInstance(NULL);
 }
 
 TEST_F(DeviceOrientationProviderTest, StartStopStart) {
   scoped_refptr<MockDeviceDataFactory> device_data_factory(
       new MockDeviceDataFactory());
   MockDeviceDataFactory::SetCurInstance(device_data_factory.get());
@@ skipping 13 matching lines @@
 
   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);
   provider_->AddObserver(checker_a.get());
-  MessageLoop::current()->Run();
+  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);
   provider_->AddObserver(checker_b.get());
-  MessageLoop::current()->Run();
+  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());
@@ skipping 10 matching lines @@
   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);
   provider_->AddObserver(checker.get());
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   // The observer should receive the same motion again.
   device_data_factory->SetDeviceData(test_motion, DeviceData::kTypeMotion);
   checker->AddExpectation(test_motion);
-  MessageLoop::current()->Run();
+  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());
   MockDeviceDataFactory::SetCurInstance(device_data_factory.get());
@@ skipping 25 matching lines @@
 
   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);
   provider_->AddObserver(checker_a.get());
-  MessageLoop::current()->Run();
+  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);
   provider_->AddObserver(checker_b.get());
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   device_data_factory->SetDeviceData(third_orientation,
       DeviceData::kTypeOrientation);
   checker_a->AddExpectation(third_orientation);
   checker_b->AddExpectation(third_orientation);
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker_a.get());
   provider_->RemoveObserver(checker_b.get());
   MockDeviceDataFactory::SetCurInstance(NULL);
 }
 
 }  // namespace
 
 }  // namespace content