Update monet.

net/url_request/url_fetcher_impl_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 "net/url_request/url_fetcher_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_element_reader.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_response_headers.h"
@@ skipping 269 matching lines @@
   static int GetNumFetcherCores() {
     return URLFetcherImpl::GetNumFetcherCores();
   }
 
   // Creates a URLRequestContextGetter with a URLRequestContext that lives on
   // the current thread.
   scoped_refptr<FetcherTestURLRequestContextGetter>
   CreateSameThreadContextGetter() {
     return scoped_refptr<FetcherTestURLRequestContextGetter>(
         new FetcherTestURLRequestContextGetter(
-            base::MessageLoopProxy::current(), hanging_url().host()));
+            base::ThreadTaskRunnerHandle::Get(), hanging_url().host()));
   }
 
   // Creates a URLRequestContextGetter with a URLRequestContext that lives on
   // a separate network thread.
   scoped_refptr<FetcherTestURLRequestContextGetter>
   CreateCrossThreadContextGetter() {
     if (!network_thread_) {
       network_thread_.reset(new base::Thread("network thread"));
       base::Thread::Options network_thread_options;
       network_thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
@@ skipping 33 matching lines @@
                     const base::FilePath& requested_out_path,
                     bool take_ownership) {
     scoped_ptr<WaitingURLFetcherDelegate> delegate(
         new WaitingURLFetcherDelegate());
     delegate->CreateFetcher(
         test_server_->GetURL(std::string(kTestServerFilePrefix) +
                              file_to_fetch),
         URLFetcher::GET, CreateSameThreadContextGetter());
     if (save_to_temporary_file) {
       delegate->fetcher()->SaveResponseToTemporaryFile(
-          scoped_refptr<base::MessageLoopProxy>(
-              base::MessageLoopProxy::current()));
+          base::ThreadTaskRunnerHandle::Get());
     } else {
       delegate->fetcher()->SaveResponseToFileAtPath(
-          requested_out_path, scoped_refptr<base::MessageLoopProxy>(
-                                  base::MessageLoopProxy::current()));
+          requested_out_path, base::ThreadTaskRunnerHandle::Get());
     }
     delegate->StartFetcherAndWait();
 
     EXPECT_TRUE(delegate->fetcher()->GetStatus().is_success());
     EXPECT_EQ(200, delegate->fetcher()->GetResponseCode());
 
     base::FilePath out_path;
     EXPECT_TRUE(
         delegate->fetcher()->GetResponseAsFilePath(take_ownership, &out_path));
     if (!save_to_temporary_file) {
@@ skipping 296 matching lines @@
 }
 
 TEST_F(URLFetcherTest, PostEntireFile) {
   base::FilePath upload_path = GetUploadFileTestPath();
 
   WaitingURLFetcherDelegate delegate;
   delegate.CreateFetcher(test_server_->GetURL("echo"), URLFetcher::POST,
                          CreateSameThreadContextGetter());
   delegate.fetcher()->SetUploadFilePath("application/x-www-form-urlencoded",
                                         upload_path, 0, kuint64max,
-                                        base::MessageLoopProxy::current());
+                                        base::ThreadTaskRunnerHandle::Get());
   delegate.StartFetcherAndWait();
 
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
 
   std::string expected;
   ASSERT_TRUE(base::ReadFileToString(upload_path, &expected));
   std::string data;
   ASSERT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_EQ(expected, data);
 }
 
 TEST_F(URLFetcherTest, PostFileRange) {
   const size_t kRangeStart = 30;
   const size_t kRangeLength = 100;
   base::FilePath upload_path = GetUploadFileTestPath();
 
   WaitingURLFetcherDelegate delegate;
   delegate.CreateFetcher(test_server_->GetURL("echo"), URLFetcher::POST,
                          CreateSameThreadContextGetter());
   delegate.fetcher()->SetUploadFilePath("application/x-www-form-urlencoded",
                                         upload_path, kRangeStart, kRangeLength,
-                                        base::MessageLoopProxy::current());
+                                        base::ThreadTaskRunnerHandle::Get());
   delegate.StartFetcherAndWait();
 
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
 
   std::string expected;
   ASSERT_TRUE(base::ReadFileToString(upload_path, &expected));
   std::string data;
   ASSERT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_EQ(expected.substr(kRangeStart, kRangeLength), data);
@@ skipping 407 matching lines @@
 
 // Make sure that the URLFetcher releases its context getter pointer on
 // cancellation, cross-thread case.
 TEST_F(URLFetcherTest, CancelDifferentThreads) {
   base::RunLoop run_loop_;
 
   WaitingURLFetcherDelegate delegate;
   scoped_refptr<FetcherTestURLRequestContextGetter> context_getter(
       CreateCrossThreadContextGetter());
   context_getter->set_on_destruction_callback(base::Bind(
-      base::IgnoreResult(&base::MessageLoopProxy::PostTask),
-      base::MessageLoopProxy::current(), FROM_HERE, run_loop_.QuitClosure()));
+      base::IgnoreResult(&base::TaskRunner::PostTask),
+      base::ThreadTaskRunnerHandle::Get(), FROM_HERE, run_loop_.QuitClosure()));
   delegate.CreateFetcher(hanging_url(), URLFetcher::GET, context_getter);
 
   // The getter won't be destroyed if the test holds on to a reference to it.
   context_getter = nullptr;
 
   delegate.fetcher()->Start();
   delegate.CancelFetch();
   run_loop_.Run();
 
   EXPECT_FALSE(delegate.did_complete());
 }
 
 TEST_F(URLFetcherTest, CancelWhileDelayedByThrottleDifferentThreads) {
   GURL url = test_server_->GetURL(kDefaultResponsePath);
   base::RunLoop run_loop_;
 
   WaitingURLFetcherDelegate delegate;
   scoped_refptr<FetcherTestURLRequestContextGetter> context_getter(
       CreateCrossThreadContextGetter());
   context_getter->set_on_destruction_callback(base::Bind(
-      base::IgnoreResult(&base::MessageLoopProxy::PostTask),
-      base::MessageLoopProxy::current(), FROM_HERE, run_loop_.QuitClosure()));
+      base::IgnoreResult(&base::TaskRunner::PostTask),
+      base::ThreadTaskRunnerHandle::Get(), FROM_HERE, run_loop_.QuitClosure()));
   delegate.CreateFetcher(url, URLFetcher::GET, context_getter);
 
   // Register an entry for test url using a sliding window of 400 seconds, and
   // max of 1 request.  Also simulate a request having just started, so the
   // next request will be affected by backoff of ~400 seconds.
   context_getter->AddThrottlerEntry(
       url, std::string() /* url_id */, 400000 /* sliding_window_period_ms */,
       1 /* max_send_threshold */, 200000 /* initial_backoff_ms */,
       2.0 /* multiply_factor */, 0.0 /* jitter_factor */,
       400000 /* maximum_backoff_ms */,
@@ skipping 187 matching lines @@
   static const char kFileToFetch[] = "simple.html";
   base::FilePath out_path = temp_dir.path().AppendASCII(kFileToFetch);
   ASSERT_TRUE(base::CreateDirectory(out_path));
   ASSERT_TRUE(base::PathExists(out_path));
 
   WaitingURLFetcherDelegate delegate;
   delegate.CreateFetcher(
       test_server_->GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
       URLFetcher::GET, CreateSameThreadContextGetter());
   delegate.fetcher()->SaveResponseToFileAtPath(
-      out_path,
-      scoped_refptr<base::MessageLoopProxy>(base::MessageLoopProxy::current()));
+      out_path, base::ThreadTaskRunnerHandle::Get());
   delegate.StartFetcherAndWait();
 
   EXPECT_FALSE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(ERR_ACCESS_DENIED, delegate.fetcher()->GetStatus().error());
 }
 
 // Get a small file and save it to a temp file.
 TEST_F(URLFetcherTest, TempFileTestSmallGet) {
   SaveFileTest("simple.html", true, base::FilePath(), false);
 }
@@ skipping 22 matching lines @@
   EXPECT_EQ(-1, delegate.fetcher()->GetResponseCode());
   EXPECT_TRUE(delegate.fetcher()->GetCookies().empty());
   std::string data;
   EXPECT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_TRUE(data.empty());
 }
 
 }  // namespace
 
 }  // namespace net