Use ScopedTaskEnvironment instead of MessageLoopForUI in device tests.

device/geolocation/geolocation_provider_impl_unittest.cc

 // Copyright 2014 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 "device/geolocation/geolocation_provider_impl.h"
 
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
+#include "base/test/scoped_task_environment.h"
+#include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "device/geolocation/access_token_store.h"
 #include "device/geolocation/fake_location_provider.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::MakeMatcher;
 using testing::Matcher;
 using testing::MatcherInterface;
 using testing::MatchResultListener;
@@ skipping 62 matching lines @@
   return MakeMatcher(new GeopositionEqMatcher(expected));
 }
 
 void DummyFunction(const LocationProvider* provider,
                    const Geoposition& position) {}
 
 }  // namespace
 
 class GeolocationProviderTest : public testing::Test {
  protected:
-  GeolocationProviderTest() : arbitrator_(new FakeLocationProvider) {
+  GeolocationProviderTest()
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::UI),
+        arbitrator_(new FakeLocationProvider) {
     provider()->SetArbitratorForTesting(base::WrapUnique(arbitrator_));
   }
 
   ~GeolocationProviderTest() override {}
 
   GeolocationProviderImpl* provider() {
     return GeolocationProviderImpl::GetInstance();
   }
 
   FakeLocationProvider* arbitrator() { return arbitrator_; }
 
   // Called on test thread.
   bool ProvidersStarted();
   void SendMockLocation(const Geoposition& position);
 
  private:
   // Called on provider thread.
   void GetProvidersStarted();
 
   // |at_exit| must be initialized before all other variables so that it is
   // available to register with Singletons and can handle tear down when the
   // test completes.
   base::ShadowingAtExitManager at_exit_;
 
-  base::MessageLoopForUI message_loop_;
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
+
+  base::ThreadChecker thread_checker_;
 
   // Owned by the GeolocationProviderImpl class.
   FakeLocationProvider* arbitrator_;
 
   // True if |arbitrator_| is started.
   bool is_started_;
 
   DISALLOW_COPY_AND_ASSIGN(GeolocationProviderTest);
 };
 
 bool GeolocationProviderTest::ProvidersStarted() {
   DCHECK(provider()->IsRunning());
-  DCHECK(base::MessageLoop::current() == &message_loop_);
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   provider()->task_runner()->PostTaskAndReply(
       FROM_HERE, base::Bind(&GeolocationProviderTest::GetProvidersStarted,
                             base::Unretained(this)),
       base::MessageLoop::QuitWhenIdleClosure());
   base::RunLoop().Run();
   return is_started_;
 }
 
 void GeolocationProviderTest::GetProvidersStarted() {
   DCHECK(provider()->task_runner()->BelongsToCurrentThread());
   is_started_ = arbitrator()->state() != FakeLocationProvider::STOPPED;
 }
 
 void GeolocationProviderTest::SendMockLocation(const Geoposition& position) {
   DCHECK(provider()->IsRunning());
-  DCHECK(base::MessageLoop::current() == &message_loop_);
+  DCHECK(thread_checker_.CalledOnValidThread());
   provider()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&GeolocationProviderImpl::OnLocationUpdate,
                  base::Unretained(provider()), arbitrator_, position));
 }
 
 // Regression test for http://crbug.com/59377
 TEST_F(GeolocationProviderTest, OnPermissionGrantedWithoutObservers) {
   // Clear |provider|'s arbitrator so the default arbitrator can be used.
   provider()->SetArbitratorForTesting(nullptr);
@@ skipping 75 matching lines @@
       base::Bind(&MockGeolocationObserver::OnLocationUpdate,
                  base::Unretained(&mock_observer));
   std::unique_ptr<GeolocationProvider::Subscription> subscription =
       provider()->AddLocationUpdateCallback(callback, false);
   subscription.reset();
   // Wait for the providers to be stopped now that all clients are gone.
   EXPECT_FALSE(ProvidersStarted());
 }
 
 }  // namespace device