components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/search_provider_logos/logo_tracker_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 "components/search_provider_logos/logo_tracker.h"
 
 #include <stdint.h>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/json/json_writer.h"
+#include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_clock.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/search_provider_logos/google_logo_api.h"
 #include "net/base/url_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 263 matching lines @@
  public:
   TestLogoDelegate() {}
   ~TestLogoDelegate() override {}
 
   void DecodeUntrustedImage(
       const scoped_refptr<base::RefCountedString>& encoded_image,
       base::Callback<void(const SkBitmap&)> image_decoded_callback) override {
     SkBitmap bitmap =
         gfx::Image::CreateFrom1xPNGBytes(encoded_image->front(),
                                          encoded_image->size()).AsBitmap();
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(image_decoded_callback, bitmap));
   }
 };
 
 class LogoTrackerTest : public ::testing::Test {
  protected:
   LogoTrackerTest()
       : message_loop_(new base::MessageLoop()),
         logo_url_("https://google.com/doodleoftheday?size=hp"),
         test_clock_(new base::SimpleTestClock()),
         logo_cache_(new NiceMock<MockLogoCache>()),
         fake_url_fetcher_factory_(NULL) {
     test_clock_->SetNow(base::Time::FromJsTime(INT64_C(1388686828000)));
-    logo_tracker_ = new LogoTracker(
-        base::FilePath(),
-        base::MessageLoopProxy::current(),
-        base::MessageLoopProxy::current(),
-        new net::TestURLRequestContextGetter(base::MessageLoopProxy::current()),
-        scoped_ptr<LogoDelegate>(new TestLogoDelegate()));
+    logo_tracker_ =
+        new LogoTracker(base::FilePath(), base::ThreadTaskRunnerHandle::Get(),
+                        base::ThreadTaskRunnerHandle::Get(),
+                        new net::TestURLRequestContextGetter(
+                            base::ThreadTaskRunnerHandle::Get()),
+                        scoped_ptr<LogoDelegate>(new TestLogoDelegate()));
     logo_tracker_->SetServerAPI(logo_url_, base::Bind(&GoogleParseLogoResponse),
                                 base::Bind(&GoogleAppendQueryparamsToLogoURL),
                                 false);
     logo_tracker_->SetClockForTests(scoped_ptr<base::Clock>(test_clock_));
     logo_tracker_->SetLogoCacheForTests(scoped_ptr<LogoCache>(logo_cache_));
   }
 
   virtual void TearDown() {
     // logo_tracker_ owns logo_cache_, which gets destructed on the file thread
     // after logo_tracker_'s destruction. Ensure that logo_cache_ is actually
@@ skipping 346 matching lines @@
 
 // Tests that deal with multiple listeners.
 
 void EnqueueObservers(LogoTracker* logo_tracker,
                       const ScopedVector<MockLogoObserver>& observers,
                       size_t start_index) {
   if (start_index >= observers.size())
     return;
 
   logo_tracker->GetLogo(observers[start_index]);
-  base::MessageLoop::current()->PostTask(FROM_HERE,
-                                         base::Bind(&EnqueueObservers,
-                                                    logo_tracker,
-                                                    base::ConstRef(observers),
-                                                    start_index + 1));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&EnqueueObservers, logo_tracker,
+                            base::ConstRef(observers), start_index + 1));
 }
 
 TEST_F(LogoTrackerTest, SupportOverlappingLogoRequests) {
   Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
   ON_CALL(*logo_cache_, SetCachedLogo(_)).WillByDefault(Return());
 
   Logo fresh_logo = GetSampleLogo2(logo_url_, test_clock_->Now());
   std::string response = ServerResponse(fresh_logo);
   SetServerResponse(response);
@@ skipping 29 matching lines @@
   MockLogoObserver listener2;
   listener2.ExpectFreshLogo(&logo);
   logo_tracker_->GetLogo(&listener2);
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 
 }  // namespace search_provider_logos