Reapply r72562 with willchan's nits + locally tested shlib fixes.

net/http/http_transaction_unittest.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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/http/http_transaction_unittest.h"
 
-#include "base/hash_tables.h"
+#include <algorithm>
+
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/load_flags.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace {
+typedef base::hash_map<std::string, const MockTransaction*> MockTransactionMap;
+static MockTransactionMap mock_transactions;
+}  // namespace
+
 //-----------------------------------------------------------------------------
 // mock transaction data
 
 const MockTransaction kSimpleGET_Transaction = {
   "http://www.google.com/",
   "GET",
   base::Time(),
   "",
   net::LOAD_NORMAL,
   "HTTP/1.1 200 OK",
@@ skipping 68 matching lines @@
 };
 
 static const MockTransaction* const kBuiltinMockTransactions[] = {
   &kSimpleGET_Transaction,
   &kSimplePOST_Transaction,
   &kTypicalGET_Transaction,
   &kETagGET_Transaction,
   &kRangeGET_Transaction
 };
 
-typedef base::hash_map<std::string, const MockTransaction*>
-MockTransactionMap;
-static MockTransactionMap mock_transactions;
-
-void AddMockTransaction(const MockTransaction* trans) {
-  mock_transactions[GURL(trans->url).spec()] = trans;
-}
-
-void RemoveMockTransaction(const MockTransaction* trans) {
-  mock_transactions.erase(GURL(trans->url).spec());
-}
-
 const MockTransaction* FindMockTransaction(const GURL& url) {
   // look for overrides:
   MockTransactionMap::const_iterator it = mock_transactions.find(url.spec());
   if (it != mock_transactions.end())
     return it->second;
 
   // look for builtins:
   for (size_t i = 0; i < arraysize(kBuiltinMockTransactions); ++i) {
     if (url == GURL(kBuiltinMockTransactions[i]->url))
       return kBuiltinMockTransactions[i];
   }
   return NULL;
 }
 
+void AddMockTransaction(const MockTransaction* trans) {
+  mock_transactions[GURL(trans->url).spec()] = trans;
+}
+
+void RemoveMockTransaction(const MockTransaction* trans) {
+  mock_transactions.erase(GURL(trans->url).spec());
+}
+
+MockHttpRequest::MockHttpRequest(const MockTransaction& t) {
+  url = GURL(t.url);
+  method = t.method;
+  extra_headers.AddHeadersFromString(t.request_headers);
+  load_flags = t.load_flags;
+}
 
 //-----------------------------------------------------------------------------
 
 // static
 int TestTransactionConsumer::quit_counter_ = 0;
 
+TestTransactionConsumer::TestTransactionConsumer(
+    net::HttpTransactionFactory* factory)
+    : state_(IDLE),
+      trans_(NULL),
+      error_(net::OK) {
+  // Disregard the error code.
+  factory->CreateTransaction(&trans_);
+  ++quit_counter_;
+}
+
+TestTransactionConsumer::~TestTransactionConsumer() {
+}
+
+void TestTransactionConsumer::Start(const net::HttpRequestInfo* request,
+                                    const net::BoundNetLog& net_log) {
+  state_ = STARTING;
+  int result = trans_->Start(request, this, net_log);
+  if (result != net::ERR_IO_PENDING)
+    DidStart(result);
+}
+
+void TestTransactionConsumer::DidStart(int result) {
+  if (result != net::OK) {
+    DidFinish(result);
+  } else {
+    Read();
+  }
+}
+
+void TestTransactionConsumer::DidRead(int result) {
+  if (result <= 0) {
+    DidFinish(result);
+  } else {
+    content_.append(read_buf_->data(), result);
+    Read();
+  }
+}
+
+void TestTransactionConsumer::DidFinish(int result) {
+  state_ = DONE;
+  error_ = result;
+  if (--quit_counter_ == 0)
+    MessageLoop::current()->Quit();
+}
+
+void TestTransactionConsumer::Read() {
+  state_ = READING;
+  read_buf_ = new net::IOBuffer(1024);
+  int result = trans_->Read(read_buf_, 1024, this);
+  if (result != net::ERR_IO_PENDING)
+    DidRead(result);
+}
+
+void TestTransactionConsumer::RunWithParams(const Tuple1<int>& params) {
+  int result = params.a;
+  switch (state_) {
+    case STARTING:
+      DidStart(result);
+      break;
+    case READING:
+      DidRead(result);
+      break;
+    default:
+      NOTREACHED();
+  }
+}
+
+
+MockNetworkTransaction::MockNetworkTransaction() :
+    ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)), data_cursor_(0) {
+}
+
+MockNetworkTransaction::~MockNetworkTransaction() {}
+
+int MockNetworkTransaction::Start(const net::HttpRequestInfo* request,
+                                  net::CompletionCallback* callback,
+                                  const net::BoundNetLog& net_log) {
+  const MockTransaction* t = FindMockTransaction(request->url);
+  if (!t)
+    return net::ERR_FAILED;
+
+  std::string resp_status = t->status;
+  std::string resp_headers = t->response_headers;
+  std::string resp_data = t->data;
+  if (t->handler)
+    (t->handler)(request, &resp_status, &resp_headers, &resp_data);
+
+  std::string header_data = base::StringPrintf(
+      "%s\n%s\n", resp_status.c_str(), resp_headers.c_str());
+  std::replace(header_data.begin(), header_data.end(), '\n', '\0');
+
+  response_.request_time = base::Time::Now();
+  if (!t->request_time.is_null())
+    response_.request_time = t->request_time;
+
+  response_.was_cached = false;
+
+  response_.response_time = base::Time::Now();
+  if (!t->response_time.is_null())
+    response_.response_time = t->response_time;
+
+  response_.headers = new net::HttpResponseHeaders(header_data);
+  response_.ssl_info.cert_status = t->cert_status;
+  data_ = resp_data;
+  test_mode_ = t->test_mode;
+
+  if (test_mode_ & TEST_MODE_SYNC_NET_START)
+    return net::OK;
+
+  CallbackLater(callback, net::OK);
+  return net::ERR_IO_PENDING;
+}
+
+int MockNetworkTransaction::RestartIgnoringLastError(
+    net::CompletionCallback* callback) {
+  return net::ERR_FAILED;
+}
+
+int MockNetworkTransaction::RestartWithCertificate(
+    net::X509Certificate* client_cert,
+    net::CompletionCallback* callback) {
+  return net::ERR_FAILED;
+}
+
+int MockNetworkTransaction::RestartWithAuth(const string16& username,
+                                            const string16& password,
+                                            net::CompletionCallback* callback) {
+  return net::ERR_FAILED;
+}
+
+bool MockNetworkTransaction::IsReadyToRestartForAuth() {
+  return false;
+}
+
+int MockNetworkTransaction::Read(net::IOBuffer* buf, int buf_len,
+                                 net::CompletionCallback* callback) {
+  int data_len = static_cast<int>(data_.size());
+  int num = std::min(buf_len, data_len - data_cursor_);
+  if (num) {
+    memcpy(buf->data(), data_.data() + data_cursor_, num);
+    data_cursor_ += num;
+  }
+  if (test_mode_ & TEST_MODE_SYNC_NET_READ)
+    return num;
+
+  CallbackLater(callback, num);
+  return net::ERR_IO_PENDING;
+}
+
+void MockNetworkTransaction::StopCaching() {}
+
+const net::HttpResponseInfo* MockNetworkTransaction::GetResponseInfo() const {
+  return &response_;
+}
+
+net::LoadState MockNetworkTransaction::GetLoadState() const {
+  if (data_cursor_)
+    return net::LOAD_STATE_READING_RESPONSE;
+  return net::LOAD_STATE_IDLE;
+}
+
+uint64 MockNetworkTransaction::GetUploadProgress() const {
+  return 0;
+}
+
+void MockNetworkTransaction::CallbackLater(net::CompletionCallback* callback,
+                                           int result) {
+  MessageLoop::current()->PostTask(FROM_HERE, task_factory_.NewRunnableMethod(
+      &MockNetworkTransaction::RunCallback, callback, result));
+}
+
+void MockNetworkTransaction::RunCallback(net::CompletionCallback* callback,
+                                         int result) {
+  callback->Run(result);
+}
+
+MockNetworkLayer::MockNetworkLayer() : transaction_count_(0) {}
+
+MockNetworkLayer::~MockNetworkLayer() {}
+
+int MockNetworkLayer::CreateTransaction(
+    scoped_ptr<net::HttpTransaction>* trans) {
+  transaction_count_++;
+  trans->reset(new MockNetworkTransaction());
+  return net::OK;
+}
+
+net::HttpCache* MockNetworkLayer::GetCache() {
+  return NULL;
+}
+
+net::HttpNetworkSession* MockNetworkLayer::GetSession() {
+  return NULL;
+}
+
+void MockNetworkLayer::Suspend(bool suspend) {}
 
 //-----------------------------------------------------------------------------
 // helpers
 
 int ReadTransaction(net::HttpTransaction* trans, std::string* result) {
   int rv;
 
   TestCompletionCallback callback;
 
   std::string content;
   do {
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
     rv = trans->Read(buf, 256, &callback);
     if (rv == net::ERR_IO_PENDING)
       rv = callback.WaitForResult();
     if (rv > 0) {
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       return rv;
     }
   } while (rv > 0);
 
   result->swap(content);
   return net::OK;
 }