Update monet.

net/test/embedded_test_server/embedded_test_server.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/test/embedded_test_server/embedded_test_server.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 175 matching lines @@
 
 void EmbeddedTestServer::StartThread() {
   DCHECK(!io_thread_.get());
   base::Thread::Options thread_options;
   thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
   io_thread_.reset(new base::Thread("EmbeddedTestServer io thread"));
   CHECK(io_thread_->StartWithOptions(thread_options));
 }
 
 void EmbeddedTestServer::InitializeOnIOThread() {
-  DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
   DCHECK(!Started());
 
   SocketDescriptor socket_descriptor =
       TCPListenSocket::CreateAndBindAnyPort("127.0.0.1", &port_);
   if (socket_descriptor == kInvalidSocket)
     return;
 
   listen_socket_.reset(new HttpListenSocket(socket_descriptor, this));
   listen_socket_->Listen();
 
   IPEndPoint address;
   int result = listen_socket_->GetLocalAddress(&address);
   if (result == OK) {
     base_url_ = GURL(std::string("http://") + address.ToString());
   } else {
     LOG(ERROR) << "GetLocalAddress failed: " << ErrorToString(result);
   }
 }
 
 void EmbeddedTestServer::ListenOnIOThread() {
-  DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
   DCHECK(Started());
   listen_socket_->ListenOnIOThread();
 }
 
 void EmbeddedTestServer::ShutdownOnIOThread() {
-  DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
 
   listen_socket_.reset();
   STLDeleteContainerPairSecondPointers(connections_.begin(),
                                        connections_.end());
   connections_.clear();
 }
 
 void EmbeddedTestServer::HandleRequest(HttpConnection* connection,
                                scoped_ptr<HttpRequest> request) {
-  DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
 
   bool request_handled = false;
 
   for (size_t i = 0; i < request_handlers_.size(); ++i) {
     scoped_ptr<HttpResponse> response =
         request_handlers_[i].Run(*request.get());
     if (response.get()) {
       connection->SendResponse(response.Pass());
       request_handled = true;
       break;
     }
   }
 
   if (!request_handled) {
     LOG(WARNING) << "Request not handled. Returning 404: "
                  << request->relative_url;
     scoped_ptr<BasicHttpResponse> not_found_response(new BasicHttpResponse);
     not_found_response->set_code(HTTP_NOT_FOUND);
     connection->SendResponse(not_found_response.Pass());
   }
 
   // Drop the connection, since we do not support multiple requests per
   // connection.
   connections_.erase(connection->socket_.get());
   delete connection;
 }
 
 GURL EmbeddedTestServer::GetURL(const std::string& relative_url) const {
   DCHECK(Started()) << "You must start the server first.";
-  DCHECK(StartsWithASCII(relative_url, "/", true /* case_sensitive */))
+  DCHECK(base::StartsWith(relative_url, "/", base::CompareCase::SENSITIVE))
       << relative_url;
   return base_url_.Resolve(relative_url);
 }
 
 GURL EmbeddedTestServer::GetURL(
     const std::string& hostname,
     const std::string& relative_url) const {
   GURL local_url = GetURL(relative_url);
   GURL::Replacements replace_host;
   replace_host.SetHostStr(hostname);
   return local_url.ReplaceComponents(replace_host);
 }
 
 void EmbeddedTestServer::ServeFilesFromDirectory(
     const base::FilePath& directory) {
   RegisterRequestHandler(base::Bind(&HandleFileRequest, directory));
 }
 
 void EmbeddedTestServer::RegisterRequestHandler(
     const HandleRequestCallback& callback) {
   request_handlers_.push_back(callback);
 }
 
 void EmbeddedTestServer::DidAccept(
     StreamListenSocket* server,
     scoped_ptr<StreamListenSocket> connection) {
-  DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
 
   HttpConnection* http_connection = new HttpConnection(
       connection.Pass(),
       base::Bind(&EmbeddedTestServer::HandleRequest,
                  weak_factory_.GetWeakPtr()));
   // TODO(szym): Make HttpConnection the StreamListenSocket delegate.
   connections_[http_connection->socket_.get()] = http_connection;
 }
 
 void EmbeddedTestServer::DidRead(StreamListenSocket* connection,
                          const char* data,
                          int length) {
-  DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
 
   HttpConnection* http_connection = FindConnection(connection);
   if (http_connection == NULL) {
     LOG(WARNING) << "Unknown connection.";
     return;
   }
   http_connection->ReceiveData(std::string(data, length));
 }
 
 void EmbeddedTestServer::DidClose(StreamListenSocket* connection) {
-  DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
 
   HttpConnection* http_connection = FindConnection(connection);
   if (http_connection == NULL) {
     LOG(WARNING) << "Unknown connection.";
     return;
   }
   delete http_connection;
   connections_.erase(connection);
 }
 
 HttpConnection* EmbeddedTestServer::FindConnection(
     StreamListenSocket* socket) {
-  DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
 
   std::map<StreamListenSocket*, HttpConnection*>::iterator it =
       connections_.find(socket);
   if (it == connections_.end()) {
     return NULL;
   }
   return it->second;
 }
 
 bool EmbeddedTestServer::PostTaskToIOThreadAndWait(
     const base::Closure& closure) {
-  // Note that PostTaskAndReply below requires base::MessageLoopProxy::current()
+  // Note that PostTaskAndReply below requires base::MessageLoop::current()
   // to return a loop for posting the reply task. However, in order to make
   // EmbeddedTestServer universally usable, it needs to cope with the situation
   // where it's running on a thread on which a message loop is not (yet)
   // available or as has been destroyed already.
   //
   // To handle this situation, create temporary message loop to support the
   // PostTaskAndReply operation if the current thread as no message loop.
   scoped_ptr<base::MessageLoop> temporary_loop;
   if (!base::MessageLoop::current())
     temporary_loop.reset(new base::MessageLoop());
 
   base::RunLoop run_loop;
-  if (!io_thread_->message_loop_proxy()->PostTaskAndReply(
-          FROM_HERE, closure, run_loop.QuitClosure())) {
+  if (!io_thread_->task_runner()->PostTaskAndReply(FROM_HERE, closure,
+                                                   run_loop.QuitClosure())) {
     return false;
   }
   run_loop.Run();
 
   return true;
 }
 
 }  // namespace test_server
 }  // namespace net