Rename net::BidirectionalStream*Job to net::BidirectionalStream*Impl

net/http/bidirectional_stream.h

 // Copyright 2015 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_BIDIRECTIONAL_STREAM_H_
 #define NET_HTTP_BIDIRECTIONAL_STREAM_H_
 
 #include <stdint.h>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
-#include "net/http/bidirectional_stream_job.h"
+#include "net/http/bidirectional_stream_impl.h"
 #include "net/http/http_stream_factory.h"
 #include "net/log/net_log.h"
 
 class GURL;
 
 namespace net {
 
 class HttpAuthController;
 class HttpNetworkSession;
 class HttpStream;
 class HttpStreamRequest;
 class IOBuffer;
 class ProxyInfo;
 class SpdyHeaderBlock;
 struct BidirectionalStreamRequestInfo;
 struct SSLConfig;
 
 // A class to do HTTP/2 bidirectional streaming. Note that at most one each of
 // ReadData or SendData should be in flight until the operation completes.
 // The BidirectionalStream must be torn down before the HttpNetworkSession.
 class NET_EXPORT BidirectionalStream
-    : public NON_EXPORTED_BASE(BidirectionalStreamJob::Delegate),
+    : public NON_EXPORTED_BASE(BidirectionalStreamImpl::Delegate),
       public NON_EXPORTED_BASE(HttpStreamRequest::Delegate) {
  public:
   // Delegate interface to get notified of success of failure. Callbacks will be
   // invoked asynchronously.
   class NET_EXPORT Delegate {
    public:
     Delegate();
 
     // Called when headers have been sent. This is called at most once for
     // the lifetime of a stream.
@@ skipping 49 matching lines @@
                       HttpNetworkSession* session,
                       Delegate* delegate);
 
   // Constructor that accepts a Timer, which can be used in tests to control
   // the buffering of received data.
   BidirectionalStream(scoped_ptr<BidirectionalStreamRequestInfo> request_info,
                       HttpNetworkSession* session,
                       Delegate* delegate,
                       scoped_ptr<base::Timer> timer);
 
-  // Cancels |stream_request_| or |stream_job_| if applicable.
+  // Cancels |stream_request_| or |stream_impl_| if applicable.
   // |this| should not be destroyed during Delegate::OnHeadersSent or
   // Delegate::OnDataSent.
   ~BidirectionalStream() override;
 
   // Reads at most |buf_len| bytes into |buf|. Returns the number of bytes read,
   // or ERR_IO_PENDING if the read is to be completed asynchronously, or an
   // error code if any error occurred. If returns 0, there is no more data to
   // read. This should not be called before Delegate::OnHeadersReceived is
   // invoked, and should not be called again unless it returns with number
   // greater than 0 or until Delegate::OnDataRead is invoked.
   int ReadData(IOBuffer* buf, int buf_len);
 
   // Sends data. This should not be called before Delegate::OnHeadersSent is
   // invoked, and should not be called again until Delegate::OnDataSent is
   // invoked. If |end_stream| is true, the DATA frame will have an END_STREAM
   // flag.
   void SendData(IOBuffer* data, int length, bool end_stream);
 
-  // If |stream_request_| is non-NULL, cancel it. If |stream_job_| is
+  // If |stream_request_| is non-NULL, cancel it. If |stream_impl_| is
   // established, cancel it. No delegate method will be called after Cancel().
   // Any pending operations may or may not succeed.
   void Cancel();
 
   // Returns the protocol used by this stream. If stream has not been
   // established, return kProtoUnknown.
   NextProto GetProtocol() const;
 
   // Total number of bytes received over the network of SPDY data, headers, and
   // push_promise frames associated with this stream, including the size of
   // frame headers, after SSL decryption and not including proxy overhead.
   // If stream has not been established, return 0.
   int64_t GetTotalReceivedBytes() const;
 
   // Total number of bytes sent over the network of SPDY frames associated with
   // this stream, including the size of frame headers, before SSL encryption and
   // not including proxy overhead. Note that some SPDY frames such as pings are
   // not associated with any stream, and are not included in this value.
   int64_t GetTotalSentBytes() const;
 
   // TODO(xunjieli): Implement a method to do flow control and a method to ping
   // remote end point.
 
  private:
-  // BidirectionalStreamJob::Delegate implementation:
+  // BidirectionalStreamImpl::Delegate implementation:
   void OnHeadersSent() override;
   void OnHeadersReceived(const SpdyHeaderBlock& response_headers) override;
   void OnDataRead(int bytes_read) override;
   void OnDataSent() override;
   void OnTrailersReceived(const SpdyHeaderBlock& trailers) override;
   void OnFailed(int error) override;
 
   // HttpStreamRequest::Delegate implementation:
   void OnStreamReady(const SSLConfig& used_ssl_config,
                      const ProxyInfo& used_proxy_info,
                      HttpStream* stream) override;
-  void OnBidirectionalStreamJobReady(const SSLConfig& used_ssl_config,
-                                     const ProxyInfo& used_proxy_info,
-                                     BidirectionalStreamJob* stream) override;
+  void OnBidirectionalStreamImplReady(const SSLConfig& used_ssl_config,
+                                      const ProxyInfo& used_proxy_info,
+                                      BidirectionalStreamImpl* stream) override;

[mef, 2016/03/21 22:00:43]

should this param be called |stream_impl|?

[xunjieli, 2016/03/22 15:24:24]

Done.

   void OnWebSocketHandshakeStreamReady(
       const SSLConfig& used_ssl_config,
       const ProxyInfo& used_proxy_info,
       WebSocketHandshakeStreamBase* stream) override;
   void OnStreamFailed(int status,
                       const SSLConfig& used_ssl_config,
                       SSLFailureState ssl_failure_state) override;
   void OnCertificateError(int status,
                           const SSLConfig& used_ssl_config,
                           const SSLInfo& ssl_info) override;
@@ skipping 11 matching lines @@
 
   // BidirectionalStreamRequestInfo used when requesting the stream.
   scoped_ptr<BidirectionalStreamRequestInfo> request_info_;
   const BoundNetLog net_log_;
 
   Delegate* const delegate_;
 
   // Timer used to buffer data received in short time-spans and send a single
   // read completion notification.
   scoped_ptr<base::Timer> timer_;
-  // HttpStreamRequest used to request a BidirectionalStreamJob. This is NULL if
-  // the request has been canceled or completed.
+  // HttpStreamRequest used to request a BidirectionalStreamImpl. This is NULL
+  // if the request has been canceled or completed.
   scoped_ptr<HttpStreamRequest> stream_request_;
   // The underlying BidirectioanlStreamJob used for this stream. It is non-NULL,

[mef, 2016/03/21 22:00:43]

BidirectionalStreamImpl

[xunjieli, 2016/03/22 15:24:24]

Done.

   // if the |stream_request_| successfully finishes.
-  scoped_ptr<BidirectionalStreamJob> stream_job_;
+  scoped_ptr<BidirectionalStreamImpl> stream_impl_;
 
   DISALLOW_COPY_AND_ASSIGN(BidirectionalStream);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_BIDIRECTIONAL_STREAM_H_