Refactors DeviceOrientation to make it more extensible

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::Observer {
  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.
-  virtual void OnOrientationUpdate(const Orientation& orientation) {
+  virtual void OnDeviceDataUpdate(const DeviceData& device_data) {
     ASSERT_FALSE(expectations_queue_.empty());
 
+    const Orientation& orientation = static_cast<const Orientation&>(
+        device_data);
     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(),
               orientation.can_provide_absolute());
     if (expected.can_provide_alpha())
       EXPECT_EQ(expected.alpha(), orientation.alpha());
@@ skipping 55 matching lines @@
     instance_ = NULL;
   }
 
   // Owned by ProviderImpl. Holds a reference back to MockOrientationFactory.
   class MockDataFetcher : public DataFetcher {
    public:
     explicit MockDataFetcher(MockOrientationFactory* orientation_factory)
         : orientation_factory_(orientation_factory) { }
 
     // From DataFetcher. Called by the Provider.
-    virtual bool GetOrientation(Orientation* orientation) {
+    virtual bool GetDeviceData(DeviceData* device_data) {
       base::AutoLock auto_lock(orientation_factory_->lock_);
       if (orientation_factory_->is_failing_)
         return false;
+      Orientation* orientation = static_cast<Orientation*>(device_data);
       *orientation = orientation_factory_->orientation_;
       return true;
     }
 
    private:
     scoped_refptr<MockOrientationFactory> orientation_factory_;
   };
 
   static MockOrientationFactory* instance_;
   Orientation orientation_;
   bool is_failing_;
   base::Lock lock_;
 };
 
 MockOrientationFactory* MockOrientationFactory::instance_;
 
 // Mock DataFetcher that always fails to provide any orientation data.
 class FailingDataFetcher : public DataFetcher {
  public:
   // Factory method; passed to and called by the ProviderImpl.
   static DataFetcher* Create() {
     return new FailingDataFetcher();
   }
 
   // From DataFetcher.
-  virtual bool GetOrientation(Orientation* orientation) {
+  virtual bool GetDeviceData(DeviceData* device_data) {
     return false;
   }
 
  private:
   FailingDataFetcher() {}
 };
 
 class DeviceOrientationProviderTest : public testing::Test {
  public:
   DeviceOrientationProviderTest()
@@ skipping 31 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());
   MessageLoop::current()->Run();
 
   checker_b->AddExpectation(Orientation::Empty());
   provider_->AddObserver(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);
   Orientation test_orientation;
   test_orientation.set_alpha(1);
   test_orientation.set_beta(2);
   test_orientation.set_gamma(3);
   test_orientation.set_absolute(true);
 
-  scoped_ptr<UpdateChecker> checker(new UpdateChecker(&pending_expectations_));
+  scoped_ptr<OrientationUpdateChecker> checker(
+      new OrientationUpdateChecker(&pending_expectations_));
   checker->AddExpectation(test_orientation);
   orientation_factory->SetOrientation(test_orientation);
   provider_->AddObserver(checker.get());
   MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker.get());
 }
 
 TEST_F(DeviceOrientationProviderTest, MultipleObserversPushTest) {
   scoped_refptr<MockOrientationFactory> orientation_factory(
@@ skipping 10 matching lines @@
   test_orientations[1].set_alpha(4);
   test_orientations[1].set_beta(5);
   test_orientations[1].set_gamma(6);
   test_orientations[1].set_absolute(false);
 
   test_orientations[2].set_alpha(7);
   test_orientations[2].set_beta(8);
   test_orientations[2].set_gamma(9);
   // can't provide absolute
 
-  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(test_orientations[0]);
   orientation_factory->SetOrientation(test_orientations[0]);
   provider_->AddObserver(checker_a.get());
   MessageLoop::current()->Run();
 
   checker_a->AddExpectation(test_orientations[1]);
   checker_b->AddExpectation(test_orientations[0]);
   checker_b->AddExpectation(test_orientations[1]);
   orientation_factory->SetOrientation(test_orientations[1]);
@@ skipping 28 matching lines @@
   test_orientation.set_beta(2);
   test_orientation.set_gamma(3);
   test_orientation.set_absolute(true);
 
   Orientation test_orientation2;
   test_orientation2.set_alpha(4);
   test_orientation2.set_beta(5);
   test_orientation2.set_gamma(6);
   test_orientation2.set_absolute(false);
 
-  scoped_ptr<UpdateChecker> checker(new UpdateChecker(&pending_expectations_));
+  scoped_ptr<OrientationUpdateChecker> checker(
+      new OrientationUpdateChecker(&pending_expectations_));
   checker->AddExpectation(test_orientation);
   orientation_factory->SetOrientation(test_orientation);
   provider_->AddObserver(checker.get());
   MessageLoop::current()->Run();
 
   checker->AddExpectation(test_orientation2);
   orientation_factory->SetOrientation(test_orientation2);
   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);
   Orientation test_orientation;
   test_orientation.set_alpha(1);
   test_orientation.set_beta(2);
   test_orientation.set_gamma(3);
   test_orientation.set_absolute(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(test_orientation);
   checker_a->AddExpectation(test_orientation);
   provider_->AddObserver(checker_a.get());
   MessageLoop::current()->Run();
 
   checker_a->AddExpectation(Orientation::Empty());
   orientation_factory->SetFailing(true);
   MessageLoop::current()->Run();
@@ skipping 16 matching lines @@
   test_orientation.set_beta(2);
   test_orientation.set_gamma(3);
   test_orientation.set_absolute(true);
 
   Orientation test_orientation2;
   test_orientation2.set_alpha(4);
   test_orientation2.set_beta(5);
   test_orientation2.set_gamma(6);
   test_orientation2.set_absolute(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(test_orientation);
   orientation_factory->SetOrientation(test_orientation);
   provider_->AddObserver(checker_a.get());
   MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker_a.get()); // This stops the Provider.
 
   checker_b->AddExpectation(test_orientation2);
@@ skipping 26 matching lines @@
   second_orientation.set_beta(kBeta + kInsignificantDifference);
   second_orientation.set_gamma(kGamma + kInsignificantDifference);
   second_orientation.set_absolute(false);
 
   Orientation third_orientation;
   third_orientation.set_alpha(kAlpha + kSignificantDifference);
   third_orientation.set_beta(kBeta + kSignificantDifference);
   third_orientation.set_gamma(kGamma + kSignificantDifference);
   // can't provide absolute
 
-  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());
   MessageLoop::current()->Run();
 
   // The observers should not see this insignificantly different orientation.
   orientation_factory->SetOrientation(second_orientation);
   checker_b->AddExpectation(first_orientation);
   provider_->AddObserver(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());
 }
 
 }  // namespace
 
 }  // namespace device_orientation