Adds a new class HttpCache::Writers for multiple cache transactions reading from the network.

net/http/http_transaction_test_util.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/http/http_transaction_test_util.h"
 
 #include <algorithm>
 #include <unordered_map>
 #include <utility>
 
@@ skipping 219 matching lines @@
       data_cursor_(0),
       content_length_(0),
       priority_(priority),
       read_handler_(nullptr),
       websocket_handshake_stream_create_helper_(nullptr),
       transaction_factory_(factory->AsWeakPtr()),
       received_bytes_(0),
       sent_bytes_(0),
       socket_log_id_(NetLogSource::kInvalidId),
       done_reading_called_(false),
+      read_error_(0),
       weak_factory_(this) {}
 
 MockNetworkTransaction::~MockNetworkTransaction() {
   // Use request_ as in ~HttpNetworkTransaction to make sure its valid and not
   // already freed by the consumer. See crbug.com/734037.
   if (request_)
     DCHECK(request_->load_flags >= 0);
 }
 
 int MockNetworkTransaction::Start(const HttpRequestInfo* request,
@@ skipping 48 matching lines @@
   // Allow the mock server to decide whether authentication is required or not.
   std::string status_line = response_.headers->GetStatusLine();
   return status_line.find(" 401 ") != std::string::npos ||
       status_line.find(" 407 ") != std::string::npos;
 }
 
 int MockNetworkTransaction::Read(net::IOBuffer* buf,
                                  int buf_len,
                                  const CompletionCallback& callback) {
   CHECK(!done_reading_called_);
-  int num = 0;
-  if (read_handler_) {
-    num = (*read_handler_)(content_length_, data_cursor_, buf, buf_len);
-    data_cursor_ += num;
-  } else {
-    int data_len = static_cast<int>(data_.size());
-    num = std::min(static_cast<int64_t>(buf_len), data_len - data_cursor_);
-    if (test_mode_ & TEST_MODE_SLOW_READ)
-      num = std::min(num, 1);
-    if (num) {
-      memcpy(buf->data(), data_.data() + data_cursor_, num);
+  int num = read_error_;
+
+  if (OK == num) {
+    if (read_handler_) {
+      num = (*read_handler_)(content_length_, data_cursor_, buf, buf_len);
       data_cursor_ += num;
+    } else {
+      int data_len = static_cast<int>(data_.size());
+      num = std::min(static_cast<int64_t>(buf_len), data_len - data_cursor_);
+      if (test_mode_ & TEST_MODE_SLOW_READ)
+        num = std::min(num, 1);
+      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 ERR_IO_PENDING;
 }
 
 void MockNetworkTransaction::StopCaching() {
   if (transaction_factory_.get())
     transaction_factory_->TransactionStopCaching();
@@ skipping 161 matching lines @@
   DCHECK(!resume_start_callback_.is_null());
   CallbackLater(resume_start_callback_, OK);
   return ERR_IO_PENDING;
 }
 
 void MockNetworkTransaction::GetConnectionAttempts(
     ConnectionAttempts* out) const {
   NOTIMPLEMENTED();
 }
 
+void MockNetworkTransaction::SetReadError(int error) {
+  read_error_ = error;
+}
+
 void MockNetworkTransaction::CallbackLater(const CompletionCallback& callback,
                                            int result) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&MockNetworkTransaction::RunCallback,
                             weak_factory_.GetWeakPtr(), callback, result));
 }
 
 void MockNetworkTransaction::RunCallback(const CompletionCallback& callback,
                                          int result) {
   callback.Run(result);
@@ skipping 74 matching lines @@
       content.append(buf->data(), rv);
     else if (rv < 0)
       return rv;
   } while (rv > 0);
 
   result->swap(content);
   return OK;
 }
 
 }  // namespace net