chrome_frame: Use base::MessageLoop.

chrome_frame/test/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 "chrome_frame/test/test_server.h"
 
 #include <windows.h>
 #include <objbase.h>
 #include <urlmon.h>
 
@@ skipping 20 matching lines @@
 const char kDefaultContentType[] = "text/html; charset=UTF-8";
 
 void Request::ParseHeaders(const std::string& headers) {
   DCHECK(method_.length() == 0);
 
   size_t pos = headers.find("\r\n");
   DCHECK(pos != std::string::npos);
   if (pos != std::string::npos) {
     headers_ = headers.substr(pos + 2);
 
-    base::StringTokenizer tokenizer(headers.begin(), headers.begin() + pos, " ");
+    base::StringTokenizer tokenizer(
+        headers.begin(), headers.begin() + pos, " ");
     std::string* parse[] = { &method_, &path_, &version_ };
     int field = 0;
     while (tokenizer.GetNext() && field < arraysize(parse)) {
       parse[field++]->assign(tokenizer.token_begin(),
                              tokenizer.token_end());
     }
   }
 
   // Check for content-length in case we're being sent some data.
   net::HttpUtil::HeadersIterator it(headers_.begin(), headers_.end(),
@@ skipping 94 matching lines @@
 }
 
 SimpleWebServer::~SimpleWebServer() {
   ConnectionList::const_iterator it;
   for (it = connections_.begin(); it != connections_.end(); ++it)
     delete (*it);
   connections_.clear();
 }
 
 void SimpleWebServer::Construct(const std::string& address, int port) {
-  CHECK(MessageLoop::current()) << "SimpleWebServer requires a message loop";
+  CHECK(base::MessageLoop::current())
+      << "SimpleWebServer requires a message loop";
   net::EnsureWinsockInit();
   AddResponse(&quit_);
   host_ = address;
   server_ = net::TCPListenSocket::CreateAndListen(address, port, this);
   LOG_IF(DFATAL, !server_.get())
       << "Failed to create listener socket at " << address << ":" << port;
 }
 
 void SimpleWebServer::AddResponse(Response* response) {
   responses_.push_back(response);
@@ skipping 182 matching lines @@
   int size = (int)data_.size();
   const char* chunk_ptr = data_.c_str() + cur_pos_;
   int bytes_to_send = std::min(options_.chunk_size_, size - cur_pos_);
 
   socket_->Send(chunk_ptr, bytes_to_send);
   VLOG(1) << "Sent(" << cur_pos_ << "," << bytes_to_send << "): "
           << base::StringPiece(chunk_ptr, bytes_to_send);
 
   cur_pos_ += bytes_to_send;
   if (cur_pos_ < size) {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::Bind(&ConfigurableConnection::SendChunk, this),
         base::TimeDelta::FromMilliseconds(options_.timeout_));
   } else {
     socket_ = 0;  // close the connection.
   }
 }
 
 void ConfigurableConnection::Close() {
   socket_ = NULL;
 }
@@ skipping 16 matching lines @@
 
   // Save the options.
   options_ = options;
 
   if (options_.speed_ == SendOptions::IMMEDIATE) {
     socket_->Send(headers);
     socket_->Send(content_length_header, true);
     socket_->Send(content);
     // Post a task to close the socket since StreamListenSocket doesn't like
     // instances to go away from within its callbacks.
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&ConfigurableConnection::Close, this));
 
     return;
   }
 
   if (options_.speed_ == SendOptions::IMMEDIATE_HEADERS_DELAYED_CONTENT) {
     socket_->Send(headers);
     socket_->Send(content_length_header, true);
     VLOG(1) << "Headers sent: " << headers << content_length_header;
     data_.append(content);
   }
 
   if (options_.speed_ == SendOptions::DELAYED) {
     data_ = headers;
     data_.append(content_length_header);
     data_.append("\r\n");
   }
 
-  MessageLoop::current()->PostDelayedTask(
+  base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(&ConfigurableConnection::SendChunk, this),
       base::TimeDelta::FromMilliseconds(options.timeout_));
 }
 
 }  // namespace test_server