PROTOTYPE: PlzNavigate: use a Mojo data pipe to stream navigation data to the renderer.

content/browser/loader/mojo_stream_writer.h

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright 2016 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 CONTENT_BROWSER_LOADER_STREAM_WRITER_H_
-#define CONTENT_BROWSER_LOADER_STREAM_WRITER_H_
+#ifndef CONTENT_BROWSER_LOADER_MOJO_STREAM_WRITER_H_
+#define CONTENT_BROWSER_LOADER_MOJO_STREAM_WRITER_H_
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "content/browser/streams/stream_write_observer.h"
+#include "mojo/message_pump/handle_watcher.h"
+#include "mojo/public/cpp/system/data_pipe.h"
 
 class GURL;
 
 namespace net {
 class IOBuffer;
 }
 
 namespace content {
 
 class ResourceController;
-class Stream;
-class StreamRegistry;
 
-// StreamWriter is a helper class for ResourceHandlers which route their output
-// into a Stream. It manages an internal buffer and handles back-pressure from
-// the Stream's reader.
-class StreamWriter : public StreamWriteObserver {
+// MojoStreamWriter is a helper class for ResourceHandlers which route their
+// output into Mojo data pipe.
+class MojoStreamWriter {
  public:
-  // Creates a new StreamWriter without an initialized Stream or controller. The
-  // controller must be set before the writer is used.
-  StreamWriter();
-  ~StreamWriter() override;
+  // Creates a new non-initialized MojoStreamWriter. Both the data pipe handle
+  // and the controller must be set before the writer is used.
+  MojoStreamWriter();
+  ~MojoStreamWriter();
 
-  Stream* stream() { return stream_.get(); }
+  bool has_stream() { return data_producer_handle_.is_valid(); }
 
   void set_controller(ResourceController* controller) {
     controller_ = controller;
   }
 
-  // When immediate mode is enabled, the |stream_| is flushed every time new
-  // data is made available by calls to OnReadCompleted.
-  void set_immediate_mode(bool enabled) { immediate_mode_ = enabled; }
-
+  // TODO(carlosk): update comment.
   // Initializes the writer with a new Stream in |registry|. |origin| will be
   // used to construct the URL for the Stream. See WebCore::BlobURL and and
   // WebCore::SecurityOrigin in Blink to understand how origin check is done on
   // resource loading.
-  void InitializeStream(StreamRegistry* registry,
-                        const GURL& origin);
+  void InitializeStream(
+      mojo::ScopedDataPipeConsumerHandle* data_consumer_handle);
 
+  // TODO(carlosk): update comment.
   // Prepares a buffer to read data from the request. This call will be followed
   // by either OnReadCompleted (on successful read or EOF) or destruction.  The
   // buffer may not be recycled until OnReadCompleted is called. If |min_size|
   // is not -1, it is the minimum size of the returned buffer.
   //
   // OnWillRead may be called before the stream is initialized. This is to
   // support MimeTypeResourceHandler which reads the initial chunk of data
   // early.
   void OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                   int* buf_size,
                   int min_size);
 
+  // TODO(carlosk): update comment.
   // A read was completed, forward the data to the Stream. If |*defer| is set to
   // true, the implementation must not continue to process the request until
   // Resume is called on |controller_|.
   //
   // InitializeStream must have been called before calling OnReadCompleted.
   void OnReadCompleted(int bytes_read, bool* defer);
 
   // Called when there is no more data to read to the stream.
   void Finalize();
 
+  static const int kReadBufSize = 32768;
+
  private:
-  // StreamWriteObserver implementation.
-  void OnSpaceAvailable(Stream* stream) override;
-  void OnClose(Stream* stream) override;
+  // TODO(carlosk): chose a more appropriate name and update comment.
+  void OnSpaceAvailable(MojoResult result);
 
   ResourceController* controller_;
-  scoped_refptr<Stream> stream_;
-  scoped_refptr<net::IOBuffer> read_buffer_;
-  bool immediate_mode_;
 
-  DISALLOW_COPY_AND_ASSIGN(StreamWriter);
+  mojo::ScopedDataPipeProducerHandle data_producer_handle_;
+
+  // TODO(carlosk): Refactor to use a mojo::Watcher.
+  mojo::common::HandleWatcher handle_watcher_;
+  void* buffer_;
+  uint32_t buffer_size_;
+
+  DISALLOW_COPY_AND_ASSIGN(MojoStreamWriter);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_LOADER_STREAM_WRITER_H_
+#endif  // CONTENT_BROWSER_LOADER_MOJO_STREAM_WRITER_H_