src/components/cronet/android/url_request_adapter.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef COMPONENTS_CRONET_ANDROID_URL_REQUEST_ADAPTER_H_
   6 #define COMPONENTS_CRONET_ANDROID_URL_REQUEST_ADAPTER_H_
   7
   8 #include <jni.h>
   9
  10 #include <string>
  11
  12 #include "base/macros.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "net/base/request_priority.h"
  16 #include "net/http/http_request_headers.h"
  17 #include "net/url_request/url_request.h"
  18
  19 namespace net {
  20 class GrowableIOBuffer;
  21 class HttpResponseHeaders;
  22 class UploadDataStream;
  23 }  // namespace net
  24
  25 namespace cronet {
  26
  27 class URLRequestContextAdapter;
  28
  29 // An adapter from the JNI |UrlRequest| object and the Chromium |URLRequest|
  30 // object.
  31 class URLRequestAdapter : public net::URLRequest::Delegate {
  32  public:
  33   // The delegate which is called when the request finishes.
  34   class URLRequestAdapterDelegate
  35       : public base::RefCountedThreadSafe<URLRequestAdapterDelegate> {
  36    public:
  37     virtual void OnResponseStarted(URLRequestAdapter* request) = 0;
  38     virtual void OnBytesRead(URLRequestAdapter* request) = 0;
  39     virtual void OnRequestFinished(URLRequestAdapter* request) = 0;
  40     virtual int ReadFromUploadChannel(net::IOBuffer* buf, int buf_length) = 0;
  41
  42    protected:
  43     friend class base::RefCountedThreadSafe<URLRequestAdapterDelegate>;
  44     virtual ~URLRequestAdapterDelegate() {}
  45   };
  46
  47   URLRequestAdapter(URLRequestContextAdapter* context,
  48                     URLRequestAdapterDelegate* delegate,
  49                     GURL url,
  50                     net::RequestPriority priority);
  51   virtual ~URLRequestAdapter();
  52
  53   // Sets the request method GET, POST etc
  54   void SetMethod(const std::string& method);
  55
  56   // Adds a header to the request
  57   void AddHeader(const std::string& name, const std::string& value);
  58
  59   // Sets the contents of the POST or PUT request
  60   void SetUploadContent(const char* bytes, int bytes_len);
  61
  62   // Sets the request to streaming upload.
  63   void SetUploadChannel(JNIEnv* env, int64 content_length);
  64
  65   // Indicates that the request body will be streamed by calling AppendChunk()
  66   // repeatedly. This must be called before Start().
  67   void EnableChunkedUpload();
  68
  69   // Appends a chunk to the POST body.
  70   // This must be called after EnableChunkedUpload() and Start().
  71   void AppendChunk(const char* bytes, int bytes_len, bool is_last_chunk);
  72
  73   // Starts the request.
  74   void Start();
  75
  76   // Cancels the request.
  77   void Cancel();
  78
  79   // Releases all resources for the request and deletes the object itself.
  80   void Destroy();
  81
  82   // Returns the URL of the request.
  83   GURL url() const { return url_; }
  84
  85   // Returns the error code after the request is complete.
  86   // Negative codes indicate system errors.
  87   int error_code() const { return error_code_; }
  88
  89   // Returns the HTTP status code.
  90   int http_status_code() const {
  91     return http_status_code_;
  92   };
  93
  94   // Returns the value of the content-length response header.
  95   int64 content_length() const { return expected_size_; }
  96
  97   // Returns the value of the content-type response header.
  98   std::string content_type() const { return content_type_; }
  99
 100   // Returns the value of the specified response header.
 101   std::string GetHeader(const std::string& name) const;
 102
 103   // Get all response headers, as a HttpResponseHeaders object.
 104   net::HttpResponseHeaders* GetResponseHeaders() const;
 105
 106   // Returns the overall number of bytes read.
 107   size_t bytes_read() const { return bytes_read_; }
 108
 109   // Returns a pointer to the downloaded data.
 110   unsigned char* Data() const;
 111
 112   // Get NPN or ALPN Negotiated Protocol (if any) from HttpResponseInfo.
 113   std::string GetNegotiatedProtocol() const;
 114
 115   virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE;
 116
 117   virtual void OnReadCompleted(net::URLRequest* request,
 118                                int bytes_read) OVERRIDE;
 119
 120  private:
 121   static void OnDestroyRequest(URLRequestAdapter* self);
 122
 123   void OnInitiateConnection();
 124   void OnCancelRequest();
 125   void OnRequestSucceeded();
 126   void OnRequestFailed();
 127   void OnRequestCompleted();
 128   void OnRequestCanceled();
 129   void OnBytesRead(int bytes_read);
 130   void OnAppendChunk(const scoped_ptr<char[]> bytes, int bytes_len,
 131                      bool is_last_chunk);
 132
 133   void Read();
 134
 135   URLRequestContextAdapter* context_;
 136   scoped_refptr<URLRequestAdapterDelegate> delegate_;
 137   GURL url_;
 138   net::RequestPriority priority_;
 139   std::string method_;
 140   net::HttpRequestHeaders headers_;
 141   scoped_ptr<net::URLRequest> url_request_;
 142   scoped_ptr<net::UploadDataStream> upload_data_stream_;
 143   scoped_refptr<net::GrowableIOBuffer> read_buffer_;
 144   int bytes_read_;
 145   int total_bytes_read_;
 146   int error_code_;
 147   int http_status_code_;
 148   std::string content_type_;
 149   bool canceled_;
 150   int64 expected_size_;
 151   bool chunked_upload_;
 152
 153   DISALLOW_COPY_AND_ASSIGN(URLRequestAdapter);
 154 };
 155
 156 }  // namespace cronet
 157
 158 #endif  // COMPONENTS_CRONET_ANDROID_URL_REQUEST_ADAPTER_H_