Rename CronetUploadDataStreamAdapter to CronetUploadDataStream.

components/cronet/android/cronet_upload_data_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 COMPONENTS_CRONET_ANDROID_CRONET_UPLOAD_DATA_STREAM_ADAPTER_H_
-#define COMPONENTS_CRONET_ANDROID_CRONET_UPLOAD_DATA_STREAM_ADAPTER_H_
+#ifndef COMPONENTS_CRONET_ANDROID_CRONET_UPLOAD_DATA_STREAM_H_
+#define COMPONENTS_CRONET_ANDROID_CRONET_UPLOAD_DATA_STREAM_H_
 
 #include "base/basictypes.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "net/base/upload_data_stream.h"
 
 namespace net {
 class IOBuffer;
 }  // namespace net
 
 namespace cronet {
 
-// The CronetUploadDataStreamAdapter is created on a Java thread, but
-// afterwards, lives and is deleted on the network thread. It's responsible for
-// invoking UploadDataStream's callbacks, and ensuring only one read/rewind
-// request sent to Java is outstanding at a time. The main complexity is around
-// Reset/Initialize calls while there's a pending read or rewind.
-class CronetUploadDataStreamAdapter : public net::UploadDataStream {
+// The CronetUploadDataStream is created on a Java thread, but afterwards, lives
+// and is deleted on the network thread. It's responsible for ensuring only one
+// read/rewind request sent to Java is outstanding at a time. The main
+// complexity is around Reset/Initialize calls while there's a pending read or
+// rewind.
+class CronetUploadDataStream : public net::UploadDataStream {
  public:
   class Delegate {
    public:
     // Called once during initial setup on the network thread, called before
     // all other methods.
     virtual void InitializeOnNetworkThread(
-        base::WeakPtr<CronetUploadDataStreamAdapter> adapter) = 0;
+        base::WeakPtr<CronetUploadDataStream> upload_data_Stream) = 0;
 
     // Called for each read request. Delegate must respond by calling
     // OnReadSuccess on the network thread asynchronous, or failing the request.
     // Only called when there's no other pending read or rewind operation.
     virtual void Read(net::IOBuffer* buffer, int buf_len) = 0;
 
     // Called to rewind the stream. Not called when already at the start of the
     // stream. The delegate must respond by calling OnRewindSuccess
     // asynchronously on the network thread, or failing the request. Only called
     // when there's no other pending read or rewind operation.
     virtual void Rewind() = 0;
 
     // Called when the adapter is destroyed. May be called when there's a

[xunjieli, 2015/05/08 20:11:27]

nit: s/adapter/upload stream.

[mmenke, 2015/05/08 20:24:18]

Done (I actually already got that one, but git cl ate my second patch set upload
attempt with a warning that I missed).

     // pending read or rewind operation. The Delegate is then responsible for
     // destroying itself.
-    virtual void OnAdapterDestroyed() = 0;
+    virtual void OnUploadDataStreamDestroyed() = 0;
 
    protected:
     Delegate() {}
     virtual ~Delegate() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
-  CronetUploadDataStreamAdapter(Delegate* delegate, int64 size);
-  ~CronetUploadDataStreamAdapter() override;
+  CronetUploadDataStream(Delegate* delegate, int64 size);
+  ~CronetUploadDataStream() override;
 
   // Failure is handled at the Java layer. These two success callbacks are
   // invoked by Java UploadDataSink upon completion of the operation.
   void OnReadSuccess(int bytes_read, bool final_chunk);
   void OnRewindSuccess();
 
  private:
   // net::UploadDataStream implementation:
   int InitInternal() override;
   int ReadInternal(net::IOBuffer* buf, int buf_len) override;
@@ skipping 24 matching lines @@
   // will only be set to false once it completes, even though ResetInternal may
   // have been called since the rewind started.
   bool rewind_in_progress_;
 
   // Set to false when a read starts, true when a rewind completes.
   bool at_front_of_stream_;
 
   Delegate* const delegate_;
 
   // Vends pointers on the network thread, though created on a Java thread.
-  base::WeakPtrFactory<CronetUploadDataStreamAdapter> weak_factory_;
+  base::WeakPtrFactory<CronetUploadDataStream> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(CronetUploadDataStreamAdapter);
+  DISALLOW_COPY_AND_ASSIGN(CronetUploadDataStream);
 };
 
 }  // namespace cronet
 
-#endif  // COMPONENTS_CRONET_ANDROID_CRONET_UPLOAD_DATA_STREAM_ADAPTER_H_
+#endif  // COMPONENTS_CRONET_ANDROID_CRONET_UPLOAD_DATA_STREAM_H_