[android_webview] Don't block the IO thread when reading from an InputStream.

android_webview/browser/net/android_stream_reader_url_request_job.h

 // Copyright (c) 2012 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 ANDROID_WEBVIEW_NATIVE_ANDROID_STREAM_READER_URL_REQUEST_JOB_H_
 #define ANDROID_WEBVIEW_NATIVE_ANDROID_STREAM_READER_URL_REQUEST_JOB_H_
 
 #include "base/android/scoped_java_ref.h"
+#include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "net/http/http_byte_range.h"
 #include "net/url_request/url_request_job.h"
 
+namespace android_webview {
+class InputStream;
+class InputStreamReader;
+}
+
+namespace base {
+class TaskRunner;
+}
+
 namespace net {
 class URLRequest;
 }
 
 // A request job that reads data from a Java InputStream.
 class AndroidStreamReaderURLRequestJob : public net::URLRequestJob {
  public:
   /*
    * We use a delegate so that we can share code for this job in slightly
    * different contexts.
    */
   class Delegate {
    public:
-    virtual base::android::ScopedJavaLocalRef<jobject> OpenInputStream(
+    virtual scoped_ptr<android_webview::InputStream> OpenInputStream(
         JNIEnv* env,
         net::URLRequest* request) = 0;
 
     virtual bool GetMimeType(
         JNIEnv* env,
         net::URLRequest* request,
-        jobject stream,
+        const android_webview::InputStream& stream,
         std::string* mime_type) = 0;
 
     virtual bool GetCharset(
         JNIEnv* env,
         net::URLRequest* request,
-        jobject stream,
+        const android_webview::InputStream& stream,
         std::string* charset) = 0;
 
     virtual ~Delegate() {}
   };
 
   AndroidStreamReaderURLRequestJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate,
       scoped_ptr<Delegate> delegate);
 
   // URLRequestJob:
   virtual void Start() OVERRIDE;
+  virtual void Kill() OVERRIDE;
   virtual bool ReadRawData(net::IOBuffer* buf,
                            int buf_size,
                            int* bytes_read) OVERRIDE;
   virtual void SetExtraRequestHeaders(
       const net::HttpRequestHeaders& headers) OVERRIDE;
   virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
   virtual bool GetCharset(std::string* charset) OVERRIDE;
 
  protected:
   virtual ~AndroidStreamReaderURLRequestJob();
 
+  // Gets the TaskRunner for the worker thread.
+  // Useful to override in tests.
+  virtual base::TaskRunner* GetWorkerThreadRunner();
+
+  // Creates an InputStreamReader instance.
+  virtual android_webview::InputStreamReader*

[joth, 2012/11/20 20:46:35]

comment ownership is not returned. (I come from a world where CreateXxx always
returned ownership. maybe use a different method name if you think of one).

[mkosiba (inactive), 2012/11/21 15:19:47]

umm.. why do you think ownership is not returned? this is a regular factory
method (in the sense that the caller must take ownership of the result), the
fact that the caller is the same class as the method is implemented shouldn't
matter.

[joth, 2012/11/21 21:11:00]

I've become too used to see scoped_ptr to indicate ownership transfer; forgot
all about refcounted. (also the scoped members below confused me into thinking
ownership was retained)

- could comment why this is virtual; seems it could be static. (or indeed, why
it exists at all)
- could return scoped_refptr<> to be super clear. (until recently it was
unadvised to do that due to the implicit conversion to T*, but now that's going 
I think it makes a lot of sense to return the full owning type and makes it
nicely consistent with contemporary scoped_ptr usage patterns.)

+      CreateStreamReader(android_webview::InputStream* stream);
+
  private:
-  // Verify the requested range against the stream size.
-  bool VerifyRequestedRange(JNIEnv* env);
+  void StartAsync();
 
-  // Skip to the first byte of the requested read range.
-  bool SkipToRequestedRange(JNIEnv* env);
-
-  void StartAsync();
+  void OnReaderSeekCompleted(int content_size);
+  void OnReaderReadCompleted(int bytes_read);
 
   net::HttpByteRange byte_range_;
   scoped_ptr<Delegate> delegate_;
-  base::android::ScopedJavaGlobalRef<jobject> stream_;
-  base::android::ScopedJavaGlobalRef<jbyteArray> buffer_;
+  scoped_refptr<android_webview::InputStreamReader> input_stream_reader_;
+  scoped_ptr<android_webview::InputStream> stream_;
   base::WeakPtrFactory<AndroidStreamReaderURLRequestJob> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AndroidStreamReaderURLRequestJob);
 };
 
-bool RegisterAndroidStreamReaderUrlRequestJob(JNIEnv* env);
-
 #endif  // ANDROID_WEBVIEW_NATIVE_ANDROID_STREAM_READER_URL_REQUEST_JOB_H_