Renaming Observer to OrientationObserver in DeviceOrientation

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 <queue>
 
 #include "base/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "content/browser/device_orientation/data_fetcher.h"
 #include "content/browser/device_orientation/orientation.h"
 #include "content/browser/device_orientation/provider.h"
 #include "content/browser/device_orientation/provider_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace device_orientation {
 namespace {
 
 // Class for checking expectations on orientation updates from the Provider.
-class UpdateChecker : public Provider::Observer {
+class OrientationUpdateChecker : public Provider::OrientationObserver {
  public:
-  explicit UpdateChecker(int* expectations_count_ptr)
+  explicit OrientationUpdateChecker(int* expectations_count_ptr)
       : expectations_count_ptr_(expectations_count_ptr) {
   }
 
-  virtual ~UpdateChecker() {}
+  virtual ~OrientationUpdateChecker() {}
 
-  // From Provider::Observer.
+  // From Provider::OrientationObserver.
   virtual void OnOrientationUpdate(const Orientation& orientation) {
     ASSERT_FALSE(expectations_queue_.empty());
 
     Orientation expected = expectations_queue_.front();
     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 139 matching lines @@
   // Provider instance under test.
   scoped_refptr<Provider> provider_;
 
   // Message loop for the test thread.
   MessageLoop message_loop_;
 };
 
 TEST_F(DeviceOrientationProviderTest, FailingTest) {
   Init(FailingDataFetcher::Create);
 
-  scoped_ptr<UpdateChecker> checker_a(
-      new UpdateChecker(&pending_expectations_));
-  scoped_ptr<UpdateChecker> checker_b(
-      new UpdateChecker(&pending_expectations_));
+  scoped_ptr<OrientationUpdateChecker> checker_a(
+      new OrientationUpdateChecker(&pending_expectations_));
+  scoped_ptr<OrientationUpdateChecker> checker_b(
+      new OrientationUpdateChecker(&pending_expectations_));
 
   checker_a->AddExpectation(Orientation::Empty());
-  provider_->AddObserver(checker_a.get());
+  provider_->AddOrientationObserver(checker_a.get());
   MessageLoop::current()->Run();
 
   checker_b->AddExpectation(Orientation::Empty());
-  provider_->AddObserver(checker_b.get());
+  provider_->AddOrientationObserver(checker_b.get());
   MessageLoop::current()->Run();
 }
 
 TEST_F(DeviceOrientationProviderTest, ProviderIsSingleton) {
   Init(FailingDataFetcher::Create);
 
   scoped_refptr<Provider> provider_a(Provider::GetInstance());
   scoped_refptr<Provider> provider_b(Provider::GetInstance());
 
   EXPECT_EQ(provider_a.get(), provider_b.get());
 }
 
 TEST_F(DeviceOrientationProviderTest, BasicPushTest) {
   scoped_refptr<MockOrientationFactory> orientation_factory(
       new MockOrientationFactory());
   Init(MockOrientationFactory::CreateDataFetcher);
   const Orientation kTestOrientation(true, 1, true, 2, true, 3, true, true);
 
-  scoped_ptr<UpdateChecker> checker(new UpdateChecker(&pending_expectations_));
+  scoped_ptr<OrientationUpdateChecker> checker(new OrientationUpdateChecker(
+      &pending_expectations_));
   checker->AddExpectation(kTestOrientation);
   orientation_factory->SetOrientation(kTestOrientation);
-  provider_->AddObserver(checker.get());
+  provider_->AddOrientationObserver(checker.get());
   MessageLoop::current()->Run();
 
-  provider_->RemoveObserver(checker.get());
+  provider_->RemoveOrientationObserver(checker.get());
 }
 
-TEST_F(DeviceOrientationProviderTest, MultipleObserversPushTest) {
+TEST_F(DeviceOrientationProviderTest, MultipleOrientationObserversPushTest) {
   scoped_refptr<MockOrientationFactory> orientation_factory(
       new MockOrientationFactory());
   Init(MockOrientationFactory::CreateDataFetcher);
   const Orientation kTestOrientations[] = {
     Orientation(true, 1, true, 2, true, 3, true, true),
     Orientation(true, 4, true, 5, true, 6, true, false),
     Orientation(true, 7, true, 8, true, 9, false, true)};
 
-  scoped_ptr<UpdateChecker> checker_a(
-      new UpdateChecker(&pending_expectations_));
-  scoped_ptr<UpdateChecker> checker_b(
-      new UpdateChecker(&pending_expectations_));
-  scoped_ptr<UpdateChecker> checker_c(
-      new UpdateChecker(&pending_expectations_));
+  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(kTestOrientations[0]);
   orientation_factory->SetOrientation(kTestOrientations[0]);
-  provider_->AddObserver(checker_a.get());
+  provider_->AddOrientationObserver(checker_a.get());
   MessageLoop::current()->Run();
 
   checker_a->AddExpectation(kTestOrientations[1]);
   checker_b->AddExpectation(kTestOrientations[0]);
   checker_b->AddExpectation(kTestOrientations[1]);
   orientation_factory->SetOrientation(kTestOrientations[1]);
-  provider_->AddObserver(checker_b.get());
+  provider_->AddOrientationObserver(checker_b.get());
   MessageLoop::current()->Run();
 
-  provider_->RemoveObserver(checker_a.get());
+  provider_->RemoveOrientationObserver(checker_a.get());
   checker_b->AddExpectation(kTestOrientations[2]);
   checker_c->AddExpectation(kTestOrientations[1]);
   checker_c->AddExpectation(kTestOrientations[2]);
   orientation_factory->SetOrientation(kTestOrientations[2]);
-  provider_->AddObserver(checker_c.get());
+  provider_->AddOrientationObserver(checker_c.get());
   MessageLoop::current()->Run();
 
-  provider_->RemoveObserver(checker_b.get());
-  provider_->RemoveObserver(checker_c.get());
+  provider_->RemoveOrientationObserver(checker_b.get());
+  provider_->RemoveOrientationObserver(checker_c.get());
 }
 
 #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
+#define MAYBE_OrientationObserverNotRemoved DISABLED_OrientationObserverNotRemoved
 #else
-#define MAYBE_ObserverNotRemoved ObserverNotRemoved
+#define MAYBE_OrientationObserverNotRemoved OrientationObserverNotRemoved
 #endif
-TEST_F(DeviceOrientationProviderTest, MAYBE_ObserverNotRemoved) {
+TEST_F(DeviceOrientationProviderTest, MAYBE_OrientationObserverNotRemoved) {
   scoped_refptr<MockOrientationFactory> orientation_factory(
       new MockOrientationFactory());
   Init(MockOrientationFactory::CreateDataFetcher);
   const Orientation kTestOrientation(true, 1, true, 2, true, 3, true, true);
   const Orientation kTestOrientation2(true, 4, true, 5, true, 6, true, false);
 
-  scoped_ptr<UpdateChecker> checker(new UpdateChecker(&pending_expectations_));
+  scoped_ptr<OrientationUpdateChecker> checker(new OrientationUpdateChecker(
+      &pending_expectations_));
   checker->AddExpectation(kTestOrientation);
   orientation_factory->SetOrientation(kTestOrientation);
-  provider_->AddObserver(checker.get());
+  provider_->AddOrientationObserver(checker.get());
   MessageLoop::current()->Run();
 
   checker->AddExpectation(kTestOrientation2);
   orientation_factory->SetOrientation(kTestOrientation2);
   MessageLoop::current()->Run();
 
   // 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<MockOrientationFactory> orientation_factory(
       new MockOrientationFactory());
   Init(MockOrientationFactory::CreateDataFetcher);
   const Orientation kTestOrientation(true, 1, true, 2, true, 3, true, true);
 
-  scoped_ptr<UpdateChecker> checker_a(new UpdateChecker(
+  scoped_ptr<OrientationUpdateChecker> checker_a(new OrientationUpdateChecker(
       &pending_expectations_));
-  scoped_ptr<UpdateChecker> checker_b(new UpdateChecker(
+  scoped_ptr<OrientationUpdateChecker> checker_b(new OrientationUpdateChecker(
       &pending_expectations_));
 
   orientation_factory->SetOrientation(kTestOrientation);
   checker_a->AddExpectation(kTestOrientation);
-  provider_->AddObserver(checker_a.get());
+  provider_->AddOrientationObserver(checker_a.get());
   MessageLoop::current()->Run();
 
   checker_a->AddExpectation(Orientation::Empty());
   orientation_factory->SetFailing(true);
   MessageLoop::current()->Run();
 
   checker_b->AddExpectation(Orientation::Empty());
-  provider_->AddObserver(checker_b.get());
+  provider_->AddOrientationObserver(checker_b.get());
   MessageLoop::current()->Run();
 
-  provider_->RemoveObserver(checker_a.get());
-  provider_->RemoveObserver(checker_b.get());
+  provider_->RemoveOrientationObserver(checker_a.get());
+  provider_->RemoveOrientationObserver(checker_b.get());
 }
 
 TEST_F(DeviceOrientationProviderTest, StartStopStart) {
   scoped_refptr<MockOrientationFactory> orientation_factory(
       new MockOrientationFactory());
   Init(MockOrientationFactory::CreateDataFetcher);
   const Orientation kTestOrientation(true, 1, true, 2, true, 3, true, true);
   const Orientation kTestOrientation2(true, 4, true, 5, true, 6, true, false);
 
-  scoped_ptr<UpdateChecker> checker_a(new UpdateChecker(
+  scoped_ptr<OrientationUpdateChecker> checker_a(new OrientationUpdateChecker(
       &pending_expectations_));
-  scoped_ptr<UpdateChecker> checker_b(new UpdateChecker(
+  scoped_ptr<OrientationUpdateChecker> checker_b(new OrientationUpdateChecker(
       &pending_expectations_));
 
   checker_a->AddExpectation(kTestOrientation);
   orientation_factory->SetOrientation(kTestOrientation);
-  provider_->AddObserver(checker_a.get());
+  provider_->AddOrientationObserver(checker_a.get());
   MessageLoop::current()->Run();
 
-  provider_->RemoveObserver(checker_a.get()); // This stops the Provider.
+  provider_->RemoveOrientationObserver(checker_a.get());
+  // This stops the Provider.

[Steve Block, 2012/07/04 15:34:38]

Comment should be above code.

 
   checker_b->AddExpectation(kTestOrientation2);
   orientation_factory->SetOrientation(kTestOrientation2);
-  provider_->AddObserver(checker_b.get());
+  provider_->AddOrientationObserver(checker_b.get());
   MessageLoop::current()->Run();
 
-  provider_->RemoveObserver(checker_b.get());
+  provider_->RemoveOrientationObserver(checker_b.get());
 }
 
 TEST_F(DeviceOrientationProviderTest, SignificantlyDifferent) {
   scoped_refptr<MockOrientationFactory> orientation_factory(
       new MockOrientationFactory());
   Init(MockOrientationFactory::CreateDataFetcher);
 
   // Values that should be well below or above the implementation's
   // significane threshold.
   const double kInsignificantDifference = 1e-6;
   const double kSignificantDifference = 30;
   const double kAlpha = 4, kBeta = 5, kGamma = 6;
 
   const Orientation first_orientation(true, kAlpha, true, kBeta, true, kGamma,
                                       true, true);
 
   const Orientation second_orientation(true, kAlpha + kInsignificantDifference,
                                        true, kBeta + kInsignificantDifference,
                                        true, kGamma + kInsignificantDifference,
                                        true, false);
 
   const Orientation third_orientation(true, kAlpha + kSignificantDifference,
                                       true, kBeta + kSignificantDifference,
                                       true, kGamma + kSignificantDifference,
                                       false, true);
 
-  scoped_ptr<UpdateChecker> checker_a(new UpdateChecker(
+  scoped_ptr<OrientationUpdateChecker> checker_a(new OrientationUpdateChecker(
       &pending_expectations_));
-  scoped_ptr<UpdateChecker> checker_b(new UpdateChecker(
+  scoped_ptr<OrientationUpdateChecker> checker_b(new OrientationUpdateChecker(
       &pending_expectations_));
 
 
   orientation_factory->SetOrientation(first_orientation);
   checker_a->AddExpectation(first_orientation);
-  provider_->AddObserver(checker_a.get());
+  provider_->AddOrientationObserver(checker_a.get());
   MessageLoop::current()->Run();
 
-  // The observers should not see this insignificantly different orientation.
+  // The orientation observers should not see this insignificantly different
+  // orientation.
   orientation_factory->SetOrientation(second_orientation);
   checker_b->AddExpectation(first_orientation);
-  provider_->AddObserver(checker_b.get());
+  provider_->AddOrientationObserver(checker_b.get());
   MessageLoop::current()->Run();
 
   orientation_factory->SetOrientation(third_orientation);
   checker_a->AddExpectation(third_orientation);
   checker_b->AddExpectation(third_orientation);
   MessageLoop::current()->Run();
 
-  provider_->RemoveObserver(checker_a.get());
-  provider_->RemoveObserver(checker_b.get());
+  provider_->RemoveOrientationObserver(checker_a.get());
+  provider_->RemoveOrientationObserver(checker_b.get());
 }
 
 }  // namespace
 
 }  // namespace device_orientation