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() {}
 
 int MockNetworkTransaction::Start(const HttpRequestInfo* request,
                                   const CompletionCallback& callback,
                                   const NetLogWithSource& net_log) {
   if (request_)
     return ERR_FAILED;
 
@@ skipping 43 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 (!num) {

[Randy Smith (Not in Mondays), 2017/06/22 21:45:05]

I find it surprising that if both read_error_ and the read_handler_ is set,
read_error_ wins.  I think that means that the handler associated with any mock
transactions added with AddMockTransaction are ignored if read_error_ is set,
but not the other attributes added with AddMockTransaction.  If this is the
behavior you want, could you work out in detail what that behavior is going to
be and document it in the header file?  If not, could you make read_handler_
being set override read_error_ being set (and document that behavior)?

[shivanisha, 2017/06/26 20:45:35]

Yes, the intention is that if error is set it will override all Read logic and
simply return the error code (synchronously/asynchronously based on test mode).
Documented the same.

+    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