Update monet.

net/spdy/spdy_network_transaction_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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/test/test_file_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "net/base/auth.h"
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_data_directory.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_server_properties.h"
@@ skipping 436 matching lines @@
   }
 
   const HttpRequestInfo& CreateFilePostRequest() {
     if (!post_request_initialized_) {
       base::FilePath file_path;
       CHECK(base::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
       CHECK_EQ(static_cast<int>(kUploadDataSize),
                base::WriteFile(file_path, kUploadData, kUploadDataSize));
 
       ScopedVector<UploadElementReader> element_readers;
-      element_readers.push_back(
-          new UploadFileElementReader(base::MessageLoopProxy::current().get(),
-                                      file_path,
-                                      0,
-                                      kUploadDataSize,
-                                      base::Time()));
+      element_readers.push_back(new UploadFileElementReader(
+          base::ThreadTaskRunnerHandle::Get().get(), file_path, 0,
+          kUploadDataSize, base::Time()));
       upload_data_stream_.reset(
           new ElementsUploadDataStream(element_readers.Pass(), 0));
 
       post_request_.method = "POST";
       post_request_.url = GURL(GetDefaultUrl());
       post_request_.upload_data_stream = upload_data_stream_.get();
       post_request_initialized_ = true;
     }
     return post_request_;
   }
 
   const HttpRequestInfo& CreateUnreadableFilePostRequest() {
     if (post_request_initialized_)
       return post_request_;
 
     base::FilePath file_path;
     CHECK(base::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
     CHECK_EQ(static_cast<int>(kUploadDataSize),
              base::WriteFile(file_path, kUploadData, kUploadDataSize));
     CHECK(base::MakeFileUnreadable(file_path));
 
     ScopedVector<UploadElementReader> element_readers;
-    element_readers.push_back(
-        new UploadFileElementReader(base::MessageLoopProxy::current().get(),
-                                    file_path,
-                                    0,
-                                    kUploadDataSize,
-                                    base::Time()));
+    element_readers.push_back(new UploadFileElementReader(
+        base::ThreadTaskRunnerHandle::Get().get(), file_path, 0,
+        kUploadDataSize, base::Time()));
     upload_data_stream_.reset(
         new ElementsUploadDataStream(element_readers.Pass(), 0));
 
     post_request_.method = "POST";
     post_request_.url = GURL(GetDefaultUrl());
     post_request_.upload_data_stream = upload_data_stream_.get();
     post_request_initialized_ = true;
     return post_request_;
   }
 
   const HttpRequestInfo& CreateComplexPostRequest() {
     if (!post_request_initialized_) {
       const int kFileRangeOffset = 1;
       const int kFileRangeLength = 3;
       CHECK_LT(kFileRangeOffset + kFileRangeLength, kUploadDataSize);
 
       base::FilePath file_path;
       CHECK(base::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
       CHECK_EQ(static_cast<int>(kUploadDataSize),
                base::WriteFile(file_path, kUploadData, kUploadDataSize));
 
       ScopedVector<UploadElementReader> element_readers;
       element_readers.push_back(
           new UploadBytesElementReader(kUploadData, kFileRangeOffset));
-      element_readers.push_back(
-          new UploadFileElementReader(base::MessageLoopProxy::current().get(),
-                                      file_path,
-                                      kFileRangeOffset,
-                                      kFileRangeLength,
-                                      base::Time()));
+      element_readers.push_back(new UploadFileElementReader(
+          base::ThreadTaskRunnerHandle::Get().get(), file_path,
+          kFileRangeOffset, kFileRangeLength, base::Time()));
       element_readers.push_back(new UploadBytesElementReader(
           kUploadData + kFileRangeOffset + kFileRangeLength,
           kUploadDataSize - (kFileRangeOffset + kFileRangeLength)));
       upload_data_stream_.reset(
           new ElementsUploadDataStream(element_readers.Pass(), 0));
 
       post_request_.method = "POST";
       post_request_.url = GURL(GetDefaultUrl());
       post_request_.upload_data_stream = upload_data_stream_.get();
       post_request_initialized_ = true;
@@ skipping 6050 matching lines @@
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   scoped_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(ssl_provider.Pass());
 }
 
 }  // namespace net