Add a blob field to ServiceWorkerFetchResponse and read the blob

content/browser/fileapi/blob_url_request_job_unittest.cc

 // Copyright 2013 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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
+#include "content/browser/fileapi/blob_url_request_job_unittest.h"
 #include "content/public/test/async_file_test_helper.h"
 #include "content/public/test/test_file_system_context.h"
 #include "net/base/io_buffer.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job_factory_impl.h"
@@ skipping 20 matching lines @@
 const char kTestFileSystemFileData2[] = "File system file test data.";
 const char kTestContentType[] = "foo/bar";
 const char kTestContentDisposition[] = "attachment; filename=foo.txt";
 
 const char kFileSystemURLOrigin[] = "http://remote";
 const fileapi::FileSystemType kFileSystemType =
     fileapi::kFileSystemTypeTemporary;
 
 }  // namespace
 
+MockURLRequestDelegate::MockURLRequestDelegate()
+    : received_data_(new net::IOBuffer(kBufferSize)) {
+}
+
+MockURLRequestDelegate::~MockURLRequestDelegate() {
+}
+
+void MockURLRequestDelegate::OnResponseStarted(net::URLRequest* request) {
+  if (request->status().is_success()) {
+    EXPECT_TRUE(request->response_headers());
+    ReadSome(request);
+  } else {
+    RequestComplete();
+  }
+}
+
+void MockURLRequestDelegate::OnReadCompleted(net::URLRequest* request,
+                                             int bytes_read) {
+  if (bytes_read > 0)
+    ReceiveData(request, bytes_read);
+  else
+    RequestComplete();
+}
+
+void MockURLRequestDelegate::ReadSome(net::URLRequest* request) {
+  if (!request->is_pending()) {
+    RequestComplete();
+    return;
+  }
+
+  int bytes_read = 0;
+  if (!request->Read(received_data_.get(), kBufferSize, &bytes_read)) {
+    if (!request->status().is_io_pending()) {
+      RequestComplete();
+    }
+    return;
+  }
+
+  ReceiveData(request, bytes_read);
+}
+
+void MockURLRequestDelegate::ReceiveData(net::URLRequest* request,
+                                         int bytes_read) {
+  if (bytes_read) {
+    response_data_.append(received_data_->data(),
+                          static_cast<size_t>(bytes_read));
+    ReadSome(request);
+  } else {
+    RequestComplete();
+  }
+}
+
+void MockURLRequestDelegate::RequestComplete() {
+  base::MessageLoop::current()->Quit();
+}
+
+MockBlobProtocolHandler::MockBlobProtocolHandler(
+    webkit_blob::BlobData* blob_data,
+    fileapi::FileSystemContext* file_system_context)
+    : blob_data_(blob_data), file_system_context_(file_system_context) {
+}
+
+net::URLRequestJob* MockBlobProtocolHandler::MaybeCreateJob(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) const {
+  return new BlobURLRequestJob(request,
+                               network_delegate,
+                               blob_data_,
+                               file_system_context_,
+                               base::MessageLoopProxy::current().get());
+}
+
 class BlobURLRequestJobTest : public testing::Test {
  public:
-
-  // Test Harness -------------------------------------------------------------
-  // TODO(jianli): share this test harness with AppCacheURLRequestJobTest
-
-  class MockURLRequestDelegate : public net::URLRequest::Delegate {
-   public:
-    MockURLRequestDelegate()
-        : received_data_(new net::IOBuffer(kBufferSize)) {}
-
-    virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE {
-      if (request->status().is_success()) {
-        EXPECT_TRUE(request->response_headers());
-        ReadSome(request);
-      } else {
-        RequestComplete();
-      }
-    }
-
-    virtual void OnReadCompleted(net::URLRequest* request,
-                                 int bytes_read) OVERRIDE {
-       if (bytes_read > 0)
-         ReceiveData(request, bytes_read);
-       else
-         RequestComplete();
-    }
-
-    const std::string& response_data() const { return response_data_; }
-
-   private:
-    void ReadSome(net::URLRequest* request) {
-      if (!request->is_pending()) {
-        RequestComplete();
-        return;
-      }
-
-      int bytes_read = 0;
-      if (!request->Read(received_data_.get(), kBufferSize, &bytes_read)) {
-        if (!request->status().is_io_pending()) {
-          RequestComplete();
-        }
-        return;
-      }
-
-      ReceiveData(request, bytes_read);
-    }
-
-    void ReceiveData(net::URLRequest* request, int bytes_read) {
-      if (bytes_read) {
-        response_data_.append(received_data_->data(),
-                              static_cast<size_t>(bytes_read));
-        ReadSome(request);
-      } else {
-        RequestComplete();
-      }
-    }
-
-    void RequestComplete() {
-      base::MessageLoop::current()->Quit();
-    }
-
-    scoped_refptr<net::IOBuffer> received_data_;
-    std::string response_data_;
-  };
-
-  // A simple ProtocolHandler implementation to create BlobURLRequestJob.
-  class MockProtocolHandler :
-      public net::URLRequestJobFactory::ProtocolHandler {
-   public:
-    MockProtocolHandler(BlobURLRequestJobTest* test) : test_(test) {}
-
-    // net::URLRequestJobFactory::ProtocolHandler override.
-    virtual net::URLRequestJob* MaybeCreateJob(
-        net::URLRequest* request,
-        net::NetworkDelegate* network_delegate) const OVERRIDE {
-      return new BlobURLRequestJob(request,
-                                   network_delegate,
-                                   test_->blob_data_.get(),
-                                   test_->file_system_context_.get(),
-                                   base::MessageLoopProxy::current().get());
-    }
-
-   private:
-    BlobURLRequestJobTest* test_;
-  };
-
   BlobURLRequestJobTest()
       : blob_data_(new BlobData()),
         expected_status_code_(0) {}
 
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     temp_file1_ = temp_dir_.path().AppendASCII("BlobFile1.dat");
     ASSERT_EQ(static_cast<int>(arraysize(kTestFileData1) - 1),
               base::WriteFile(temp_file1_, kTestFileData1,
                                    arraysize(kTestFileData1) - 1));
     base::File::Info file_info1;
     base::GetFileInfo(temp_file1_, &file_info1);
     temp_file_modification_time1_ = file_info1.last_modified;
 
     temp_file2_ = temp_dir_.path().AppendASCII("BlobFile2.dat");
     ASSERT_EQ(static_cast<int>(arraysize(kTestFileData2) - 1),
               base::WriteFile(temp_file2_, kTestFileData2,
                                    arraysize(kTestFileData2) - 1));
     base::File::Info file_info2;
     base::GetFileInfo(temp_file2_, &file_info2);
     temp_file_modification_time2_ = file_info2.last_modified;
 
-    url_request_job_factory_.SetProtocolHandler("blob",
-                                                new MockProtocolHandler(this));
+    file_system_context_ =
+        CreateFileSystemContextForTesting(NULL, temp_dir_.path());
+    url_request_job_factory_.SetProtocolHandler(
+        "blob",
+        new MockBlobProtocolHandler(blob_data_.get(),
+                                    file_system_context_.get()));
     url_request_context_.set_job_factory(&url_request_job_factory_);
   }
 
   virtual void TearDown() {
   }
 
   void SetUpFileSystem() {
     // Prepare file system.
-    file_system_context_ = CreateFileSystemContextForTesting(
-        NULL, temp_dir_.path());
-
     file_system_context_->OpenFileSystem(
         GURL(kFileSystemURLOrigin),
         kFileSystemType,
         fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
         base::Bind(&BlobURLRequestJobTest::OnValidateFileSystem,
                    base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
     ASSERT_TRUE(file_system_root_url_.is_valid());
 
     // Prepare files on file system.
@@ skipping 283 matching lines @@
   EXPECT_TRUE(request_->response_headers()->GetMimeType(&content_type));
   EXPECT_EQ(kTestContentType, content_type);
   void* iter = NULL;
   std::string content_disposition;
   EXPECT_TRUE(request_->response_headers()->EnumerateHeader(
       &iter, "Content-Disposition", &content_disposition));
   EXPECT_EQ(kTestContentDisposition, content_disposition);
 }
 
 }  // namespace content