Update monet.

net/ssl/channel_id_service_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 "net/ssl/channel_id_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "crypto/ec_private_key.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/cert/asn1_util.h"
 #include "net/cert/x509_certificate.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
@@ skipping 87 matching lines @@
                                                     err,
                                                     server_identifier_,
                                                     expiration_time,
                                                     private_key,
                                                     cert));
 }
 
 class ChannelIDServiceTest : public testing::Test {
  public:
   ChannelIDServiceTest()
-      : service_(new ChannelIDService(
-            new DefaultChannelIDStore(NULL),
-            base::MessageLoopProxy::current())) {
-  }
+      : service_(new ChannelIDService(new DefaultChannelIDStore(NULL),
+                                      base::ThreadTaskRunnerHandle::Get())) {}
 
  protected:
   scoped_ptr<ChannelIDService> service_;
 };
 
 TEST_F(ChannelIDServiceTest, GetDomainForHost) {
   EXPECT_EQ("google.com",
             ChannelIDService::GetDomainForHost("google.com"));
   EXPECT_EQ("google.com",
             ChannelIDService::GetDomainForHost("www.google.com"));
@@ skipping 443 matching lines @@
   EXPECT_EQ(OK, error);
   EXPECT_FALSE(request_handle.is_active());
   EXPECT_EQ(2, service_->cert_count());
   EXPECT_STREQ("c", private_key_info2.c_str());
   EXPECT_STREQ("d", der_cert2.c_str());
 }
 
 TEST_F(ChannelIDServiceTest, AsyncStoreGetOrCreateNoChannelIDsInStore) {
   MockChannelIDStoreWithAsyncGet* mock_store =
       new MockChannelIDStoreWithAsyncGet();
-  service_ = scoped_ptr<ChannelIDService>(new ChannelIDService(
-      mock_store, base::MessageLoopProxy::current()));
+  service_ = scoped_ptr<ChannelIDService>(
+      new ChannelIDService(mock_store, base::ThreadTaskRunnerHandle::Get()));
 
   std::string host("encrypted.google.com");
 
   int error;
   TestCompletionCallback callback;
   ChannelIDService::RequestHandle request_handle;
 
   // Asynchronous completion with no certs in the store.
   std::string private_key_info, der_cert;
   EXPECT_EQ(0, service_->cert_count());
   error = service_->GetOrCreateChannelID(
       host, &private_key_info, &der_cert, callback.callback(), &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle.is_active());
 
   mock_store->CallGetChannelIDCallbackWithResult(
       ERR_FILE_NOT_FOUND, base::Time(), std::string(), std::string());
 
   error = callback.WaitForResult();
   EXPECT_EQ(OK, error);
   EXPECT_EQ(1, service_->cert_count());
   EXPECT_FALSE(private_key_info.empty());
   EXPECT_FALSE(der_cert.empty());
   EXPECT_FALSE(request_handle.is_active());
 }
 
 TEST_F(ChannelIDServiceTest, AsyncStoreGetNoChannelIDsInStore) {
   MockChannelIDStoreWithAsyncGet* mock_store =
       new MockChannelIDStoreWithAsyncGet();
-  service_ = scoped_ptr<ChannelIDService>(new ChannelIDService(
-      mock_store, base::MessageLoopProxy::current()));
+  service_ = scoped_ptr<ChannelIDService>(
+      new ChannelIDService(mock_store, base::ThreadTaskRunnerHandle::Get()));
 
   std::string host("encrypted.google.com");
 
   int error;
   TestCompletionCallback callback;
   ChannelIDService::RequestHandle request_handle;
 
   // Asynchronous completion with no certs in the store.
   std::string private_key, der_cert;
   EXPECT_EQ(0, service_->cert_count());
   error = service_->GetChannelID(
       host, &private_key, &der_cert, callback.callback(), &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle.is_active());
 
   mock_store->CallGetChannelIDCallbackWithResult(
       ERR_FILE_NOT_FOUND, base::Time(), std::string(), std::string());
 
   error = callback.WaitForResult();
   EXPECT_EQ(ERR_FILE_NOT_FOUND, error);
   EXPECT_EQ(0, service_->cert_count());
   EXPECT_EQ(0u, service_->workers_created());
   EXPECT_TRUE(der_cert.empty());
   EXPECT_FALSE(request_handle.is_active());
 }
 
 TEST_F(ChannelIDServiceTest, AsyncStoreGetOrCreateOneCertInStore) {
   MockChannelIDStoreWithAsyncGet* mock_store =
       new MockChannelIDStoreWithAsyncGet();
-  service_ = scoped_ptr<ChannelIDService>(new ChannelIDService(
-      mock_store, base::MessageLoopProxy::current()));
+  service_ = scoped_ptr<ChannelIDService>(
+      new ChannelIDService(mock_store, base::ThreadTaskRunnerHandle::Get()));
 
   std::string host("encrypted.google.com");
 
   int error;
   TestCompletionCallback callback;
   ChannelIDService::RequestHandle request_handle;
 
   // Asynchronous completion with a cert in the store.
   std::string private_key_info, der_cert;
   EXPECT_EQ(0, service_->cert_count());
@@ skipping 14 matching lines @@
   // created.
   EXPECT_EQ(0u, service_->workers_created());
   EXPECT_STREQ("ab", private_key_info.c_str());
   EXPECT_STREQ("cd", der_cert.c_str());
   EXPECT_FALSE(request_handle.is_active());
 }
 
 TEST_F(ChannelIDServiceTest, AsyncStoreGetOneCertInStore) {
   MockChannelIDStoreWithAsyncGet* mock_store =
       new MockChannelIDStoreWithAsyncGet();
-  service_ = scoped_ptr<ChannelIDService>(new ChannelIDService(
-      mock_store, base::MessageLoopProxy::current()));
+  service_ = scoped_ptr<ChannelIDService>(
+      new ChannelIDService(mock_store, base::ThreadTaskRunnerHandle::Get()));
 
   std::string host("encrypted.google.com");
 
   int error;
   TestCompletionCallback callback;
   ChannelIDService::RequestHandle request_handle;
 
   // Asynchronous completion with a cert in the store.
   std::string private_key, der_cert;
   EXPECT_EQ(0, service_->cert_count());
@@ skipping 13 matching lines @@
   // Because the cert was found in the store, no new workers should have been
   // created.
   EXPECT_EQ(0u, service_->workers_created());
   EXPECT_STREQ("cd", der_cert.c_str());
   EXPECT_FALSE(request_handle.is_active());
 }
 
 TEST_F(ChannelIDServiceTest, AsyncStoreGetThenCreateNoCertsInStore) {
   MockChannelIDStoreWithAsyncGet* mock_store =
       new MockChannelIDStoreWithAsyncGet();
-  service_ = scoped_ptr<ChannelIDService>(new ChannelIDService(
-      mock_store, base::MessageLoopProxy::current()));
+  service_ = scoped_ptr<ChannelIDService>(
+      new ChannelIDService(mock_store, base::ThreadTaskRunnerHandle::Get()));
 
   std::string host("encrypted.google.com");
 
   int error;
 
   // Asynchronous get with no certs in the store.
   TestCompletionCallback callback1;
   ChannelIDService::RequestHandle request_handle1;
   std::string private_key1, der_cert1;
   EXPECT_EQ(0, service_->cert_count());
@@ skipping 31 matching lines @@
   EXPECT_EQ(der_cert1, der_cert2);
   EXPECT_FALSE(private_key1.empty());
   EXPECT_EQ(private_key1, private_key2);
   EXPECT_FALSE(request_handle1.is_active());
   EXPECT_FALSE(request_handle2.is_active());
 }
 
 }  // namespace
 
 }  // namespace net