device_orientation::ProviderImpl to stop polling thread asynchronously

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"
@@ skipping 52 matching lines @@
   // message_loop_.
   int* expectations_count_ptr_;
   std::queue<Orientation> expectations_queue_;
 };
 
 // Class for injecting test orientation data into the Provider.
 class MockOrientationFactory : public base::RefCounted<MockOrientationFactory> {
  public:
   MockOrientationFactory()
       : is_failing_(false) {
-    EXPECT_FALSE(instance_);
-    instance_ = this;
+  }
+
+  static void SetCurInstance(MockOrientationFactory* instance) {
+    if (instance) {
+      EXPECT_FALSE(instance_);
+    }
+    else {
+      EXPECT_TRUE(instance_);
+    }
+    instance_ = instance;
   }
 
   static DataFetcher* CreateDataFetcher() {
     EXPECT_TRUE(instance_);
     return new MockDataFetcher(instance_);
   }
 
   void SetOrientation(const Orientation& orientation) {
     base::AutoLock auto_lock(lock_);
     orientation_ = orientation;
   }
 
   void SetFailing(bool is_failing) {
     base::AutoLock auto_lock(lock_);
     is_failing_ = is_failing;
   }
 
  private:
   friend class base::RefCounted<MockOrientationFactory>;
 
   ~MockOrientationFactory() {
-    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) {
@@ skipping 96 matching lines @@
 
   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());
+  MockOrientationFactory::SetCurInstance(orientation_factory.get());
   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_));
   checker->AddExpectation(test_orientation);
   orientation_factory->SetOrientation(test_orientation);
   provider_->AddObserver(checker.get());
   MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker.get());
+  MockOrientationFactory::SetCurInstance(NULL);
 }
 
 TEST_F(DeviceOrientationProviderTest, MultipleObserversPushTest) {
   scoped_refptr<MockOrientationFactory> orientation_factory(
       new MockOrientationFactory());
+  MockOrientationFactory::SetCurInstance(orientation_factory.get());
   Init(MockOrientationFactory::CreateDataFetcher);
 
   Orientation test_orientations[] = {Orientation(), Orientation(),
                                      Orientation()};
   test_orientations[0].set_alpha(1);
   test_orientations[0].set_beta(2);
   test_orientations[0].set_gamma(3);
   test_orientations[0].set_absolute(true);
 
   test_orientations[1].set_alpha(4);
@@ skipping 28 matching lines @@
   provider_->RemoveObserver(checker_a.get());
   checker_b->AddExpectation(test_orientations[2]);
   checker_c->AddExpectation(test_orientations[1]);
   checker_c->AddExpectation(test_orientations[2]);
   orientation_factory->SetOrientation(test_orientations[2]);
   provider_->AddObserver(checker_c.get());
   MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker_b.get());
   provider_->RemoveObserver(checker_c.get());
+  MockOrientationFactory::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
 #else
 #define MAYBE_ObserverNotRemoved ObserverNotRemoved
 #endif
 TEST_F(DeviceOrientationProviderTest, MAYBE_ObserverNotRemoved) {
   scoped_refptr<MockOrientationFactory> orientation_factory(
       new MockOrientationFactory());
+  MockOrientationFactory::SetCurInstance(orientation_factory.get());
   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);
 
   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_));
   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();
 
+  MockOrientationFactory::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<MockOrientationFactory> orientation_factory(
       new MockOrientationFactory());
+  MockOrientationFactory::SetCurInstance(orientation_factory.get());
   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(
       &pending_expectations_));
   scoped_ptr<UpdateChecker> checker_b(new UpdateChecker(
       &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();
 
   checker_b->AddExpectation(Orientation::Empty());
   provider_->AddObserver(checker_b.get());
   MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker_a.get());
   provider_->RemoveObserver(checker_b.get());
+  MockOrientationFactory::SetCurInstance(NULL);
 }
 
 TEST_F(DeviceOrientationProviderTest, StartStopStart) {
   scoped_refptr<MockOrientationFactory> orientation_factory(
       new MockOrientationFactory());
+  MockOrientationFactory::SetCurInstance(orientation_factory.get());
   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);
 
   Orientation test_orientation2;
   test_orientation2.set_alpha(4);
@@ skipping 12 matching lines @@
   MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker_a.get()); // This stops the Provider.
 
   checker_b->AddExpectation(test_orientation2);
   orientation_factory->SetOrientation(test_orientation2);
   provider_->AddObserver(checker_b.get());
   MessageLoop::current()->Run();
 
   provider_->RemoveObserver(checker_b.get());
+  MockOrientationFactory::SetCurInstance(NULL);
 }
 
 TEST_F(DeviceOrientationProviderTest, SignificantlyDifferent) {
   scoped_refptr<MockOrientationFactory> orientation_factory(
       new MockOrientationFactory());
+  MockOrientationFactory::SetCurInstance(orientation_factory.get());
   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;
 
   Orientation first_orientation;
   first_orientation.set_alpha(kAlpha);
@@ skipping 30 matching lines @@
   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());
+  MockOrientationFactory::SetCurInstance(NULL);
 }
 
 }  // namespace
 
 }  // namespace device_orientation