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

net/http/http_cache_writers.h

Index: net/http/http_cache_writers.h
diff --git a/net/http/http_cache_writers.h b/net/http/http_cache_writers.h
new file mode 100644
index 0000000000000000000000000000000000000000..bdd95edd5006eaab63fef8cda377756f61388cf4
--- /dev/null
+++ b/net/http/http_cache_writers.h
@@ -0,0 +1,227 @@
+// Copyright (c) 2017 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_HTTP_CACHE_WRITERS_H_
+#define NET_HTTP_HTTP_CACHE_WRITERS_H_
+
+#include <list>
+#include <memory>
+
+#include "base/memory/weak_ptr.h"
+#include "net/base/completion_callback.h"
+#include "net/http/http_cache.h"
+
+namespace net {
+
+// If multiple HttpCache::Transactions are accessing the same cache entry
+// simultaneously, their access to the data read from network is synchronized
+// by HttpCache::Writers. This enables each of those transactions to drive
+// reading the response body from the network ensuring a slow consumer does not
+// starve other consumers of the same resource.
+//
+// Writers represents the set of all HttpCache::Transactions that are
+// reading from the network using the same network transaction and writing to
+// the same cache entry. It is owned by the ActiveEntry.
+class NET_EXPORT_PRIVATE HttpCache::Writers {
+ public:
+  // |entry| must outlive this object.
+  Writers(disk_cache::Entry* entry);
+  ~Writers();
+
+  // Retrieves data from the network transaction associated with the Writers
+  // object. This may be done directly (via a network read into |*buf->data()|)
+  // or indirectly (by copying from another transactions buffer into
+  // |*buf->data()| on network read completion) depending on whether or not a
+  // read is currently in progress. May return the result synchronously or
+  // return ERR_IO_PENDING: if ERR_IO_PENDING is returned, |callback| will be
+  // run to inform the consumer of the result of the Read().
+  // |transaction| may be removed while Read() is ongoing. In that case Writers
+  // will still complete the Read() processing but will not invoke the
+  // |callback|.
+  int Read(scoped_refptr<IOBuffer> buf,
+           int buf_len,
+           const CompletionCallback& callback,
+           Transaction* transaction);
+
+  // Invoked when StopCaching is called on a member transaction.
+  // It stops caching only if there are no other transactions. Returns true if
+  // caching can be stopped.
+  // TODO(shivanisha@) Also document this conditional stopping in
+  // HttpTransaction on integration.
+  bool StopCaching(Transaction* transaction);
+
+  // Adds an HttpCache::Transaction to Writers and if it's the first transaction
+  // added, transfers the ownership of the network transaction to Writers.
+  // Should only be invoked if CanAddWriters() returns true.
+  // |network_transaction| should be non-null only for the first transaction
+  // and it will be assigned to |network_transaction_|. If |is_exclusive| is
+  // true, it makes writing an exclusive operation implying that Writers can
+  // contain at most one transaction till the completion of the response body.
+  // |transaction| can be destroyed at any point and it should invoke
+  // RemoveTransaction() during its destruction.
+  void AddTransaction(Transaction* transaction,
+                      std::unique_ptr<HttpTransaction> network_transaction,
+                      bool is_exclusive);
+
+  // Removes a transaction. Should be invoked when this transaction is
+  // destroyed.
+  void RemoveTransaction(Transaction* transaction);
+
+  // Invoked when there is a change in a member transaction's priority or a
+  // member transaction is removed.
+  void UpdatePriority();
+
+  // Returns true if this object is empty.
+  bool IsEmpty() const { return all_writers_.empty(); }
+
+  // Returns true if |transaction| is part of writers.
+  bool HasTransaction(Transaction* transaction) const {
+    return all_writers_.count(transaction) > 0;
+  }
+
+  // Remove and return any idle writers. Should only be invoked when a
+  // response is completely written and when ContainesOnlyIdleWriters()
+  // returns true.
+  TransactionSet RemoveAllIdleWriters();
+
+  // Returns true if more writers can be added for shared writing.
+  bool CanAddWriters();
+
+  // TODO(shivanisha), Check if this function gets invoked in the integration
+  // CL. Remove if not.
+  HttpTransaction* network_transaction() { return network_transaction_.get(); }
+
+  // Invoked to mark an entry as truncated. This must only be invoked when there
+  // is no ongoing Read() call.
+  void TruncateEntry();
+
+  // Should be invoked only when writers has transactions attached to it and
+  // thus has a valid network transaction.
+  LoadState GetWriterLoadState();
+
+  // For testing.
+  int CountTransactionsForTesting() const { return all_writers_.size(); }
+  bool IsTruncatedForTesting() const { return truncated_; }
+
+ private:
+  friend class WritersTest;
+
+  enum class State {
+    UNSET,
+    NONE,
+    NETWORK_READ,
+    NETWORK_READ_COMPLETE,
+    CACHE_WRITE_DATA,
+    CACHE_WRITE_DATA_COMPLETE,
+    CACHE_WRITE_TRUNCATED_RESPONSE,
+    CACHE_WRITE_TRUNCATED_RESPONSE_COMPLETE,
+  };
+
+  // These transactions are waiting on Read. After the active transaction
+  // completes writing the data to the cache, their buffer would be filled with
+  // the data and their callback will be invoked.
+  struct WaitingForRead {
+    Transaction* transaction;
+    scoped_refptr<IOBuffer> read_buf;
+    int read_buf_len;
+    int write_len;
+    const CompletionCallback callback;
+    WaitingForRead(Transaction* transaction,
+                   scoped_refptr<IOBuffer> read_buf,
+                   int len,
+                   const CompletionCallback& consumer_callback);
+    ~WaitingForRead();
+    WaitingForRead(const WaitingForRead&);
+  };
+  using WaitingForReadList = std::list<WaitingForRead>;
+
+  // Runs the state transition loop. Resets and calls |callback_| on exit,
+  // unless the return value is ERR_IO_PENDING.
+  int DoLoop(int result);
+
+  // State machine functions.
+  int DoNetworkRead();
+  int DoNetworkReadComplete(int result);
+  int DoCacheWriteData(int num_bytes);
+  int DoCacheWriteDataComplete(int result);
+  int DoCacheWriteTruncatedResponse();
+  int DoCacheWriteTruncatedResponseComplete(int result);
+
+  // Helper functions for callback.
+  void OnNetworkReadFailure(int result);
+  void OnCacheWriteFailure();
+  void OnDataReceived(int result);
+
+  // Notifies the transactions waiting on Read of the result, by posting a task
+  // for each of them.
+  void ProcessWaitingForReadTransactions(int result);
+
+  // Sets the state to FAIL_READ so that any subsequent Read on an idle
+  // transaction fails.
+  void SetIdleWritersFailState(int result);
+
+  // Called to reset state when all transaction references are removed from
+  // |this|.
+  void ResetStateForEmptyWriters();
+
+  // Invoked when |active_transaction_| fails to read from network or write to
+  // cache. |error| indicates network read error code or cache write error.
+  void ProcessFailure(Transaction* transaction, int error);
+
+  // Returns true if |this| only contains idle writers. Idle writers are those
+  // that are waiting for Read to be invoked by the consumer.
+  bool ContainsOnlyIdleWriters() const;
+
+  // IO Completion callback function.
+  void OnIOComplete(int result);
+
+  State next_state_ = State::NONE;
+
+  // True if only reading from network and not writing to cache.
+  bool network_read_only_ = false;
+
+  // TODO(shivanisha) Add HttpCache* cache_ = nullptr; on integration.
+
+  disk_cache::Entry* disk_entry_ = nullptr;
+
+  std::unique_ptr<HttpTransaction> network_transaction_ = nullptr;
+
+  scoped_refptr<IOBuffer> read_buf_ = nullptr;
+
+  int io_buf_len_ = 0;
+  int write_len_ = 0;
+
+  // The cache transaction that is the current consumer of network_transaction_
+  // ::Read or writing to the entry and is waiting for the operation to be
+  // completed. This is used to ensure there is at most one consumer of
+  // network_transaction_ at a time.
+  Transaction* active_transaction_ = nullptr;
+
+  // Transactions whose consumers have invoked Read, but another transaction is
+  // currently the |active_transaction_|. After the network read and cache write
+  // is complete, the waiting transactions will be notified.
+  WaitingForReadList waiting_for_read_;
+
+  // Includes all transactions. ResetStateForEmptyWriters should be invoked
+  // whenever all_writers_ becomes empty.
+  TransactionSet all_writers_;
+
+  // True if multiple transactions are not allowed e.g. for partial requests.
+  bool is_exclusive_ = false;
+
+  // Current priority of the request. It is always the maximum of all the writer
+  // transactions.
+  RequestPriority priority_ = MINIMUM_PRIORITY;
+
+  bool truncated_ = false;  // used for testing.
+
+  CompletionCallback callback_;  // Callback for active_transaction_.
+
+  base::WeakPtrFactory<Writers> weak_factory_;
+  DISALLOW_COPY_AND_ASSIGN(Writers);
+};
+
+}  // namespace net
+
+#endif  // NET_HTTP_HTTP_CACHE_WRITERS_H_