Revert "Clean up net unit testing code." since it breaks the shlib builder.

This reverts commit 006f377bbb65ece3490b7c76e58e0dc4cb330909 (r72562).

BUG=68682
TEST=compiles
TBR=thomasvl

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@72564 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 213 insertions, 315 deletions

diff --git a/net/http/http_auth_handler_factory_unittest.cc b/net/http/http_auth_handler_factory_unittest.cc
index 3145c4b..fb6e370 100644
--- a/net/http/http_auth_handler_factory_unittest.cc
+++ b/net/http/http_auth_handler_factory_unittest.cc
@@ -7,7 +7,6 @@
 #include "net/base/net_errors.h"
 #include "net/http/http_auth_handler.h"
 #include "net/http/http_auth_handler_factory.h"
-#include "net/http/mock_allow_url_security_manager.h"
 #include "net/http/url_security_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -98,7 +97,7 @@ TEST(HttpAuthHandlerFactoryTest, RegistryFactory) {
 
 TEST(HttpAuthHandlerFactoryTest, DefaultFactory) {
   scoped_ptr<HostResolver> host_resolver(new MockHostResolver());
-  MockAllowURLSecurityManager url_security_manager;
+  URLSecurityManagerAllow url_security_manager;
   scoped_ptr<HttpAuthHandlerRegistryFactory> http_auth_handler_factory(
       HttpAuthHandlerFactory::CreateDefault(host_resolver.get()));
   http_auth_handler_factory->SetURLSecurityManager(
diff --git a/net/http/http_auth_handler_negotiate_unittest.cc b/net/http/http_auth_handler_negotiate_unittest.cc
index bb57151..684ff55 100644
--- a/net/http/http_auth_handler_negotiate_unittest.cc
+++ b/net/http/http_auth_handler_negotiate_unittest.cc
@@ -10,7 +10,6 @@
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_request_info.h"
-#include "net/http/mock_allow_url_security_manager.h"
 #if defined(OS_WIN)
 #include "net/http/mock_sspi_library_win.h"
 #elif defined(OS_POSIX)
@@ -37,7 +36,7 @@ class HttpAuthHandlerNegotiateTest : public PlatformTest {
     resolver_->rules()->AddIPLiteralRule("alias", "10.0.0.2",
                                            "canonical.example.com");
 
-    url_security_manager_.reset(new MockAllowURLSecurityManager());
+    url_security_manager_.reset(new URLSecurityManagerAllow());
     factory_.reset(new HttpAuthHandlerNegotiate::Factory());
     factory_->set_url_security_manager(url_security_manager_.get());
     factory_->set_library(auth_library_);
diff --git a/net/http/http_auth_unittest.cc b/net/http/http_auth_unittest.cc
index 6788be2..f45d215 100644
--- a/net/http/http_auth_unittest.cc
+++ b/net/http/http_auth_unittest.cc
@@ -17,7 +17,6 @@
 #include "net/http/http_auth_handler_mock.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
-#include "net/http/mock_allow_url_security_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ -116,7 +115,7 @@ TEST(HttpAuthTest, ChooseBestChallenge) {
   };
   GURL origin("http://www.example.com");
   std::set<HttpAuth::Scheme> disabled_schemes;
-  MockAllowURLSecurityManager url_security_manager;
+  URLSecurityManagerAllow url_security_manager;
   scoped_ptr<HostResolver> host_resolver(new MockHostResolver());
   scoped_ptr<HttpAuthHandlerRegistryFactory> http_auth_handler_factory(
       HttpAuthHandlerFactory::CreateDefault(host_resolver.get()));
diff --git a/net/http/http_transaction_unittest.cc b/net/http/http_transaction_unittest.cc
index fabfb01..518c1f8 100644
--- a/net/http/http_transaction_unittest.cc
+++ b/net/http/http_transaction_unittest.cc
@@ -1,11 +1,10 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2006-2008 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 <algorithm>
-
+#include "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
@@ -17,11 +16,6 @@
 #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
 
@@ -110,6 +104,18 @@ static const MockTransaction* const kBuiltinMockTransactions[] = {
   &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());
@@ -124,222 +130,12 @@ const MockTransaction* FindMockTransaction(const GURL& url) {
   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
diff --git a/net/http/http_transaction_unittest.h b/net/http/http_transaction_unittest.h
index 0a11bb5..3149534 100644
--- a/net/http/http_transaction_unittest.h
+++ b/net/http/http_transaction_unittest.h
@@ -8,11 +8,15 @@
 
 #include "net/http/http_transaction.h"
 
+#include <algorithm>
 #include <string>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/message_loop.h"
 #include "base/string16.h"
+#include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
@@ -23,10 +27,6 @@
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 
-namespace net {
-class IOBuffer;
-}
-
 //-----------------------------------------------------------------------------
 // mock transaction data
 
@@ -97,7 +97,12 @@ struct ScopedMockTransaction : MockTransaction {
 
 class MockHttpRequest : public net::HttpRequestInfo {
  public:
-  explicit MockHttpRequest(const MockTransaction& t);
+  explicit MockHttpRequest(const MockTransaction& t) {
+    url = GURL(t.url);
+    method = t.method;
+    extra_headers.AddHeadersFromString(t.request_headers);
+    load_flags = t.load_flags;
+  }
 };
 
 //-----------------------------------------------------------------------------
@@ -105,11 +110,25 @@ class MockHttpRequest : public net::HttpRequestInfo {
 
 class TestTransactionConsumer : public CallbackRunner< Tuple1<int> > {
  public:
-  explicit TestTransactionConsumer(net::HttpTransactionFactory* factory);
-  virtual ~TestTransactionConsumer();
+  explicit TestTransactionConsumer(net::HttpTransactionFactory* factory)
+      : state_(IDLE),
+        trans_(NULL),
+        error_(net::OK) {
+    // Disregard the error code.
+    factory->CreateTransaction(&trans_);
+    ++quit_counter_;
+  }
+
+  ~TestTransactionConsumer() {
+  }
 
   void Start(const net::HttpRequestInfo* request,
-             const net::BoundNetLog& net_log);
+             const net::BoundNetLog& net_log) {
+    state_ = STARTING;
+    int result = trans_->Start(request, this, net_log);
+    if (result != net::ERR_IO_PENDING)
+      DidStart(result);
+  }
 
   bool is_done() const { return state_ == DONE; }
   int error() const { return error_; }
@@ -120,22 +139,60 @@ class TestTransactionConsumer : public CallbackRunner< Tuple1<int> > {
   const std::string& content() const { return content_; }
 
  private:
+  // Callback implementation:
+  virtual void RunWithParams(const Tuple1<int>& params) {
+    int result = params.a;
+    switch (state_) {
+      case STARTING:
+        DidStart(result);
+        break;
+      case READING:
+        DidRead(result);
+        break;
+      default:
+        NOTREACHED();
+    }
+  }
+
+  void DidStart(int result) {
+    if (result != net::OK) {
+      DidFinish(result);
+    } else {
+      Read();
+    }
+  }
+
+  void DidRead(int result) {
+    if (result <= 0) {
+      DidFinish(result);
+    } else {
+      content_.append(read_buf_->data(), result);
+      Read();
+    }
+  }
+
+  void DidFinish(int result) {
+    state_ = DONE;
+    error_ = result;
+    if (--quit_counter_ == 0)
+      MessageLoop::current()->Quit();
+  }
+
+  void 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);
+  }
+
   enum State {
     IDLE,
     STARTING,
     READING,
     DONE
-  };
-
-  void DidStart(int result);
-  void DidRead(int result);
-  void DidFinish(int result);
-  void Read();
-
-  // Callback implementation:
-  virtual void RunWithParams(const Tuple1<int>& params);
+  } state_;
 
-  State state_;
   scoped_ptr<net::HttpTransaction> trans_;
   std::string content_;
   scoped_refptr<net::IOBuffer> read_buf_;
@@ -153,38 +210,107 @@ class TestTransactionConsumer : public CallbackRunner< Tuple1<int> > {
 // HttpCache implementation.
 class MockNetworkTransaction : public net::HttpTransaction {
  public:
-  MockNetworkTransaction();
-  virtual ~MockNetworkTransaction();
+  MockNetworkTransaction() :
+      ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)), data_cursor_(0) {
+  }
 
   virtual int Start(const net::HttpRequestInfo* request,
                     net::CompletionCallback* callback,
-                    const net::BoundNetLog& net_log);
+                    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;
 
-  virtual int RestartIgnoringLastError(net::CompletionCallback* callback);
+    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;
+  }
+
+  virtual int RestartIgnoringLastError(net::CompletionCallback* callback) {
+    return net::ERR_FAILED;
+  }
 
   virtual int RestartWithCertificate(net::X509Certificate* client_cert,
-                                     net::CompletionCallback* callback);
+                                     net::CompletionCallback* callback) {
+    return net::ERR_FAILED;
+  }
 
   virtual int RestartWithAuth(const string16& username,
                               const string16& password,
-                              net::CompletionCallback* callback);
+                              net::CompletionCallback* callback) {
+    return net::ERR_FAILED;
+  }
 
-  virtual bool IsReadyToRestartForAuth();
+  virtual bool IsReadyToRestartForAuth() {
+    return false;
+  }
 
   virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::CompletionCallback* callback);
+                   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;
+  }
 
-  virtual void StopCaching();
+  virtual void StopCaching() {}
 
-  virtual const net::HttpResponseInfo* GetResponseInfo() const;
+  virtual const net::HttpResponseInfo* GetResponseInfo() const {
+    return &response_;
+  }
 
-  virtual net::LoadState GetLoadState() const;
+  virtual net::LoadState GetLoadState() const {
+    if (data_cursor_)
+      return net::LOAD_STATE_READING_RESPONSE;
+    return net::LOAD_STATE_IDLE;
+  }
 
-  virtual uint64 GetUploadProgress() const;
+  virtual uint64 GetUploadProgress() const {
+    return 0;
+  }
 
  private:
-  void CallbackLater(net::CompletionCallback* callback, int result);
-  void RunCallback(net::CompletionCallback* callback, int result);
+  void CallbackLater(net::CompletionCallback* callback, int result) {
+    MessageLoop::current()->PostTask(FROM_HERE, task_factory_.NewRunnableMethod(
+        &MockNetworkTransaction::RunCallback, callback, result));
+  }
+  void RunCallback(net::CompletionCallback* callback, int result) {
+    callback->Run(result);
+  }
 
   ScopedRunnableMethodFactory<MockNetworkTransaction> task_factory_;
   net::HttpResponseInfo response_;
@@ -195,21 +321,32 @@ class MockNetworkTransaction : public net::HttpTransaction {
 
 class MockNetworkLayer : public net::HttpTransactionFactory {
  public:
-  MockNetworkLayer();
-  virtual ~MockNetworkLayer();
+  MockNetworkLayer() : transaction_count_(0) {
+  }
 
-  int transaction_count() const { return transaction_count_; }
+  virtual int CreateTransaction(scoped_ptr<net::HttpTransaction>* trans) {
+    transaction_count_++;
+    trans->reset(new MockNetworkTransaction());
+    return net::OK;
+  }
+
+  virtual net::HttpCache* GetCache() {
+    return NULL;
+  }
+
+  virtual net::HttpNetworkSession* GetSession() {
+    return NULL;
+  }
 
-  // net::HttpTransactionFactory:
-  virtual int CreateTransaction(scoped_ptr<net::HttpTransaction>* trans);
-  virtual net::HttpCache* GetCache();
-  virtual net::HttpNetworkSession* GetSession();
-  virtual void Suspend(bool suspend);
+  virtual void Suspend(bool suspend) {}
+
+  int transaction_count() const { return transaction_count_; }
 
  private:
   int transaction_count_;
 };
 
+
 //-----------------------------------------------------------------------------
 // helpers
 
diff --git a/net/http/mock_allow_url_security_manager.cc b/net/http/mock_allow_url_security_manager.cc
deleted file mode 100644
index e8b2c4f..0000000
--- a/net/http/mock_allow_url_security_manager.cc
+++ /dev/null
@@ -1,22 +0,0 @@
-// 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/mock_allow_url_security_manager.h"
-
-namespace net {
-
-MockAllowURLSecurityManager::MockAllowURLSecurityManager() {}
-
-MockAllowURLSecurityManager::~MockAllowURLSecurityManager() {}
-
-bool MockAllowURLSecurityManager::CanUseDefaultCredentials(
-    const GURL& auth_origin) const {
-  return true;
-}
-
-bool MockAllowURLSecurityManager::CanDelegate(const GURL& auth_origin) const {
-  return true;
-}
-
-}  // namespace net
diff --git a/net/http/mock_allow_url_security_manager.h b/net/http/mock_allow_url_security_manager.h
deleted file mode 100644
index 32f572e..0000000
--- a/net/http/mock_allow_url_security_manager.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// 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.
-
-#ifndef NET_HTTP_MOCK_ALLOW_URL_SECURITY_MANAGER_H_
-#define NET_HTTP_MOCK_ALLOW_URL_SECURITY_MANAGER_H_
-#pragma once
-
-#include "net/http/url_security_manager.h"
-
-namespace net {
-
-// An URLSecurityManager which is very permissive and which should only be used
-// in unit testing.
-class MockAllowURLSecurityManager : public URLSecurityManager {
- public:
-  MockAllowURLSecurityManager();
-  virtual ~MockAllowURLSecurityManager();
-
-  virtual bool CanUseDefaultCredentials(const GURL& auth_origin) const;
-  virtual bool CanDelegate(const GURL& auth_origin) const;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockAllowURLSecurityManager);
-};
-
-}  // namespace net
-
-#endif  // NET_HTTP_MOCK_ALLOW_URL_SECURITY_MANAGER_H_
diff --git a/net/http/url_security_manager.h b/net/http/url_security_manager.h
index 119d6bd..c6a5ec9 100644
--- a/net/http/url_security_manager.h
+++ b/net/http/url_security_manager.h
@@ -74,6 +74,25 @@ class URLSecurityManagerWhitelist : public URLSecurityManager {
   DISALLOW_COPY_AND_ASSIGN(URLSecurityManagerWhitelist);
 };
 
+#if defined(UNIT_TEST)
+// An URLSecurityManager which is very permissive.
+class URLSecurityManagerAllow : public URLSecurityManager {
+ public:
+  URLSecurityManagerAllow() {}
+  virtual ~URLSecurityManagerAllow() {}
+
+  virtual bool CanUseDefaultCredentials(const GURL& auth_origin) const {
+    return true;
+  }
+  virtual bool CanDelegate(const GURL& auth_origin) const {
+    return true;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(URLSecurityManagerAllow);
+};
+#endif  // defined(UNIT_TEST)
+
 }  // namespace net
 
 #endif  // NET_HTTP_URL_SECURITY_MANAGER_H_