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

android_webview/native/android_stream_reader_url_request_job_unittest.cc

+// 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.
+
+#include "android_webview/browser/net/aw_url_request_job_factory.h"
+#include "android_webview/native/android_stream_reader_url_request_job.h"
+#include "android_webview/native/input_stream.h"
+#include "android_webview/native/input_stream_reader.h"
+#include "base/format_macros.h"
+#include "base/message_loop.h"
+#include "base/stringprintf.h"
+#include "net/url_request/url_request_job_factory_impl.h"
+#include "net/url_request/url_request_test_util.h"
+#include "base/debug/debugger.h"
+
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using android_webview::InputStream;
+using android_webview::InputStreamReader;
+using testing::DoAll;
+using testing::Ge;
+using testing::Gt;
+using testing::InSequence;
+using testing::Invoke;
+using testing::InvokeWithoutArgs;
+using testing::NotNull;
+using testing::Return;
+using testing::SaveArg;
+using testing::SetArgPointee;
+using testing::StrictMock;
+using testing::Test;
+using testing::WithArg;
+using testing::WithArgs;
+using testing::_;
+
+class MockInputStream : public InputStream {
+ public:
+  MockInputStream() {}
+  virtual ~MockInputStream() {}
+
+  MOCK_CONST_METHOD2(BytesAvailable, bool(JNIEnv* env, int* bytes_available));
+
+  MOCK_METHOD3(Skip,
+               bool(JNIEnv* env, int64_t n, int64_t* bytes_skipped));
+
+  MOCK_METHOD4(Read,
+               bool(JNIEnv* env,
+                    net::IOBuffer* dest,
+                    int length,
+                    int* bytes_read));
+};
+
+class StreamReaderDelegate :
+    public AndroidStreamReaderURLRequestJob::Delegate {
+ public:
+  StreamReaderDelegate(scoped_ptr<InputStream> stream)
+      : stream_(stream.Pass()) {
+  }
+
+  virtual scoped_ptr<InputStream> OpenInputStream(
+      JNIEnv* env,
+      net::URLRequest* request) {
+    return stream_.Pass();
+  }
+
+  virtual bool GetMimeType(
+      JNIEnv* env,
+      net::URLRequest* request,
+      const android_webview::InputStream& stream,
+      std::string* mime_type) {
+    return false;
+  }
+
+  virtual bool GetCharset(
+      JNIEnv* env,
+      net::URLRequest* request,
+      const android_webview::InputStream& stream,
+      std::string* charset) {
+    return false;
+  }
+ private:
+  scoped_ptr<InputStream> stream_;
+};
+
+class TestStreamReader : public InputStreamReader {
+ public:
+  TestStreamReader(InputStream* stream) : InputStreamReader(stream) {}
+  static InputStreamReader* Create(InputStream* stream) {
+    return new TestStreamReader(stream);
+  }
+ protected:
+  virtual void PostCompletionCallback(const net::CompletionCallback& callback,
+                                      int result) {
+    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, result));
+  }
+};
+
+class MockInputStreamReader : public TestStreamReader {
+ public:
+  MockInputStreamReader(InputStream* stream) : TestStreamReader(stream) {}
+
+  MOCK_METHOD2(Seek, void(net::HttpByteRange byte_range,
+                          net::CompletionCallback on_seek_completion));
+
+  MOCK_METHOD3(ReadRawData, void(net::IOBuffer* buffer,
+                                 int buffer_size,
+                                 net::CompletionCallback on_read_completion));
+
+  using TestStreamReader::PostCompletionCallback;
+};
+
+
+class TestStreamReaderJob : public AndroidStreamReaderURLRequestJob {

[joth, 2012/11/07 16:55:38]

this is tricky to follow: you're subclassing the thingy under test (which is
nice to avoid if you can)m but also double subclassing it's direct dependency
(InputStreamReader) and subclassin that class's delegate, and then also
subclassing the transitive dependency InputStream.
Some docs for why each of these testing seams is needed might help, but it's a
lot of test-only doubles for the next person to have to wade through.

[mkosiba (inactive), 2012/11/15 19:18:50]

these unittests are really more like integration tests. I'll try and simplify
the whole thing and see how much of these I can remove.

+ public:
+  TestStreamReaderJob(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate,
+      scoped_ptr<Delegate> delegate)
+      : AndroidStreamReaderURLRequestJob(request,
+                                         network_delegate,
+                                         delegate.Pass()) {
+  }
+
+  MOCK_METHOD1(CreateStreamReader, InputStreamReader*(InputStream* stream));
+ protected:
+  virtual ~TestStreamReaderJob() {}
+  virtual void PostToWorkerThread(const tracked_objects::Location& from_here,
+                                  const base::Closure& task) {
+    MessageLoop::current()->PostTask(from_here, task);
+  }
+};
+
+class AndroidStreamReaderURLRequestJobTest : public Test {
+ public:
+  AndroidStreamReaderURLRequestJobTest()
+      : loop_(MessageLoop::TYPE_IO),
+        test_gurl_("content://foo") {
+  }
+ protected:
+  virtual void SetUp() {
+    context_.set_job_factory(&factory_);
+    context_.set_network_delegate(&network_delegate_);
+    factory_.AddInterceptor(&interceptor_);
+  }
+
+  void SetRange(net::URLRequest* req, int first_byte, int last_byte) {
+    net::HttpRequestHeaders headers;
+    headers.SetHeader(net::HttpRequestHeaders::kRange,
+                      base::StringPrintf(
+                           "bytes=%" PRIuS "-%" PRIuS,
+                           first_byte, last_byte));
+    req->SetExtraRequestHeaders(headers);
+  }
+
+  MessageLoop loop_;
+  TestURLRequestContext context_;
+  TestJobInterceptor interceptor_;
+  android_webview::AwURLRequestJobFactory factory_;
+  TestDelegate url_request_delegate_;
+  TestNetworkDelegate network_delegate_;
+  GURL test_gurl_;
+};
+
+TEST_F(AndroidStreamReaderURLRequestJobTest, ReadEmptyStream) {
+  TestURLRequest req(test_gurl_, &url_request_delegate_, &context_);
+
+  StrictMock<MockInputStream>* input_stream = new StrictMock<MockInputStream>;
+  {
+    InSequence s;
+    EXPECT_CALL(*input_stream, BytesAvailable(_, NotNull()))
+        .WillOnce(DoAll(SetArgPointee<1>(0),
+                        Return(true)));
+    EXPECT_CALL(*input_stream, Read(_, NotNull(), Gt(0), NotNull()))
+        .WillOnce(DoAll(SetArgPointee<3>(0),
+                        Return(true)));
+  }
+
+  scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>
+      stream_reader_delegate(new StreamReaderDelegate(
+          make_scoped_ptr<InputStream>(input_stream)));
+  TestStreamReaderJob* test_stream_reader_job =
+      new TestStreamReaderJob(
+          &req,
+          &network_delegate_,
+          stream_reader_delegate.Pass());
+  EXPECT_CALL(*test_stream_reader_job, CreateStreamReader(_))
+      .WillOnce(Invoke(&TestStreamReader::Create));
+  interceptor_.set_main_intercept_job(test_stream_reader_job);
+
+  req.set_method("GET");
+  req.Start();
+
+  MessageLoop::current()->Run();
+
+  EXPECT_FALSE(url_request_delegate_.request_failed());
+  EXPECT_EQ(1, network_delegate_.completed_requests());
+}
+
+TEST_F(AndroidStreamReaderURLRequestJobTest, ReadPartOfStream) {
+  TestURLRequest req(test_gurl_, &url_request_delegate_, &context_);
+
+  StrictMock<MockInputStream>* input_stream = new StrictMock<MockInputStream>;
+  const int bytes_available = 128;
+  const int offset = 32;
+  const int bytes_to_read = bytes_available - offset;
+  {
+    InSequence s;
+    EXPECT_CALL(*input_stream, BytesAvailable(_, NotNull()))
+        .WillOnce(DoAll(SetArgPointee<1>(bytes_available),
+                        Return(true)));
+    EXPECT_CALL(*input_stream, Skip(_, offset, NotNull()))
+        .WillOnce(DoAll(SetArgPointee<2>(offset),
+                        Return(true)));
+    EXPECT_CALL(*input_stream,
+                Read(_, NotNull(), Ge(bytes_to_read), NotNull()))
+        .WillOnce(DoAll(SetArgPointee<3>(bytes_to_read/2),
+                        Return(true)));
+    EXPECT_CALL(*input_stream,
+                Read(_, NotNull(), Ge(bytes_to_read), NotNull()))
+        .WillOnce(DoAll(SetArgPointee<3>(bytes_to_read/2),
+                        Return(true)));
+    EXPECT_CALL(*input_stream,
+                Read(_, NotNull(), Ge(bytes_to_read), NotNull()))
+        .WillOnce(DoAll(SetArgPointee<3>(0),
+                        Return(true)));
+  }
+
+  scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>
+      stream_reader_delegate(new StreamReaderDelegate(
+          make_scoped_ptr<InputStream>(input_stream)));
+  TestStreamReaderJob* test_stream_reader_job =
+      new TestStreamReaderJob(
+          &req,
+          &network_delegate_,
+          stream_reader_delegate.Pass());
+  EXPECT_CALL(*test_stream_reader_job, CreateStreamReader(_))
+      .WillOnce(Invoke(&TestStreamReader::Create));
+  interceptor_.set_main_intercept_job(test_stream_reader_job);
+
+  req.set_method("GET");
+  SetRange(&req, offset, bytes_available);
+  req.Start();
+
+  MessageLoop::current()->Run();
+
+  EXPECT_FALSE(url_request_delegate_.request_failed());
+  EXPECT_EQ(bytes_to_read, url_request_delegate_.bytes_received());
+  EXPECT_EQ(1, network_delegate_.completed_requests());
+}
+
+TEST_F(AndroidStreamReaderURLRequestJobTest,
+       ReadStreamWithMoreAvailableThanActual) {
+  TestURLRequest req(test_gurl_, &url_request_delegate_, &context_);
+
+  StrictMock<MockInputStream>* input_stream = new StrictMock<MockInputStream>;
+  const int bytes_available_reported = 190;
+  const int bytes_available = 128;
+  const int offset = 0;
+  const int bytes_to_read = bytes_available - offset;
+  {
+    InSequence s;
+    EXPECT_CALL(*input_stream, BytesAvailable(_, NotNull()))
+        .WillOnce(DoAll(SetArgPointee<1>(bytes_available_reported),
+                        Return(true)));
+    ON_CALL(*input_stream, Skip(_, offset, NotNull()))
+        .WillByDefault(DoAll(SetArgPointee<2>(offset),
+                             Return(true)));
+    EXPECT_CALL(*input_stream,
+                Read(_, NotNull(), Ge(bytes_to_read), NotNull()))
+        .WillOnce(DoAll(SetArgPointee<3>(bytes_to_read),
+                        Return(true)));
+    EXPECT_CALL(*input_stream,
+                Read(_, NotNull(), Ge(bytes_to_read), NotNull()))
+        .WillOnce(DoAll(SetArgPointee<3>(0),
+                        Return(true)));
+  }
+
+  scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>
+      stream_reader_delegate(new StreamReaderDelegate(
+          make_scoped_ptr<InputStream>(input_stream)));
+  TestStreamReaderJob* test_stream_reader_job =
+      new TestStreamReaderJob(
+          &req,
+          &network_delegate_,
+          stream_reader_delegate.Pass());
+  EXPECT_CALL(*test_stream_reader_job, CreateStreamReader(_))
+      .WillOnce(Invoke(&TestStreamReader::Create));
+  interceptor_.set_main_intercept_job(test_stream_reader_job);
+
+  req.set_method("GET");
+  SetRange(&req, offset, bytes_available_reported);
+  req.Start();
+
+  MessageLoop::current()->Run();
+
+  EXPECT_FALSE(url_request_delegate_.request_failed());
+  EXPECT_EQ(bytes_to_read, url_request_delegate_.bytes_received());
+  EXPECT_EQ(1, network_delegate_.completed_requests());
+}
+
+void PostQuitClosure() {
+  MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+}
+
+TEST_F(AndroidStreamReaderURLRequestJobTest, DeleteJobMidWaySeek) {
+  TestURLRequest req(test_gurl_, &url_request_delegate_, &context_);
+
+  const int offset = 20;
+  StrictMock<MockInputStream>* input_stream = new StrictMock<MockInputStream>;
+  StrictMock<MockInputStreamReader>* stream_reader =
+      new StrictMock<MockInputStreamReader>(input_stream);
+  net::CompletionCallback seek_completion_callback;
+  EXPECT_CALL(*stream_reader, Seek(_, _))
+      .WillOnce(DoAll(SaveArg<1>(&seek_completion_callback),
+                      InvokeWithoutArgs(PostQuitClosure)));
+  EXPECT_CALL(*stream_reader, ReadRawData(_, _, _))
+      .Times(0);
+
+  scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>
+      stream_reader_delegate(new StreamReaderDelegate(
+          make_scoped_ptr<InputStream>(input_stream)));
+  TestStreamReaderJob* test_stream_reader_job =
+      new TestStreamReaderJob(
+          &req,
+          &network_delegate_,
+          stream_reader_delegate.Pass());
+  EXPECT_CALL(*test_stream_reader_job, CreateStreamReader(_))
+      .WillOnce(Return(stream_reader));
+  interceptor_.set_main_intercept_job(test_stream_reader_job);
+
+  req.set_method("GET");
+  SetRange(&req, offset, offset + 10);
+  req.Start();
+
+  MessageLoop::current()->Run();
+
+  ASSERT_TRUE(!seek_completion_callback.is_null());
+
+  EXPECT_EQ(0, network_delegate_.completed_requests());
+  req.Cancel();
+  EXPECT_EQ(1, network_delegate_.completed_requests());
+
+  // Call to see that it doesn't crash.
+  seek_completion_callback.Run(offset);
+}
+
+ACTION_P2(PostCompletionCallback, reader, result) {
+  reader->PostCompletionCallback(arg1, result);
+}
+
+TEST_F(AndroidStreamReaderURLRequestJobTest, DeleteJobMidWayRead) {
+  TestURLRequest req(test_gurl_, &url_request_delegate_, &context_);
+
+  const int offset = 20;
+  StrictMock<MockInputStream>* input_stream = new StrictMock<MockInputStream>;
+  StrictMock<MockInputStreamReader>* stream_reader =
+      new StrictMock<MockInputStreamReader>(input_stream);
+  net::CompletionCallback read_completion_callback;
+  EXPECT_CALL(*stream_reader, Seek(_, _))
+      .WillOnce(PostCompletionCallback(stream_reader, offset));
+  EXPECT_CALL(*stream_reader, ReadRawData(_, _, _))
+      .WillOnce(DoAll(SaveArg<2>(&read_completion_callback),
+                      InvokeWithoutArgs(PostQuitClosure)));
+
+  scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>
+      stream_reader_delegate(new StreamReaderDelegate(
+          make_scoped_ptr<InputStream>(input_stream)));
+  TestStreamReaderJob* test_stream_reader_job =
+      new TestStreamReaderJob(
+          &req,
+          &network_delegate_,
+          stream_reader_delegate.Pass());
+  EXPECT_CALL(*test_stream_reader_job, CreateStreamReader(_))
+      .WillOnce(Return(stream_reader));
+  interceptor_.set_main_intercept_job(test_stream_reader_job);
+
+  req.set_method("GET");
+  SetRange(&req, offset, offset + 10);
+  req.Start();
+
+  MessageLoop::current()->Run();
+
+  ASSERT_TRUE(!read_completion_callback.is_null());
+
+  EXPECT_EQ(0, network_delegate_.completed_requests());
+  req.Cancel();
+  EXPECT_EQ(1, network_delegate_.completed_requests());
+
+  // Call to see that it doesn't crash.
+  read_completion_callback.Run(offset);
+}