#include "base/basictypes.h"
#include "base/bind.h"
-#include "base/file_util.h"
#include "base/files/file_path.h"
+#include "base/files/file_util.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/mock_url_request_delegate.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/url_request/url_request.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_job_factory_impl.h"
+#include "storage/browser/blob/blob_url_request_job.h"
+#include "storage/browser/fileapi/file_system_context.h"
+#include "storage/browser/fileapi/file_system_operation_context.h"
+#include "storage/browser/fileapi/file_system_url.h"
+#include "storage/common/blob/blob_data.h"
#include "testing/gtest/include/gtest/gtest.h"
-#include "webkit/browser/blob/blob_url_request_job.h"
-#include "webkit/browser/fileapi/file_system_context.h"
-#include "webkit/browser/fileapi/file_system_operation_context.h"
-#include "webkit/browser/fileapi/file_system_url.h"
-#include "webkit/common/blob/blob_data.h"
-using webkit_blob::BlobData;
-using webkit_blob::BlobURLRequestJob;
+using storage::BlobData;
+using storage::BlobURLRequestJob;
namespace content {
const char kTestContentDisposition[] = "attachment; filename=foo.txt";
const char kFileSystemURLOrigin[] = "http://remote";
-const fileapi::FileSystemType kFileSystemType =
- fileapi::kFileSystemTypeTemporary;
+const storage::FileSystemType kFileSystemType =
+ storage::kFileSystemTypeTemporary;
} // namespace
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 {
MockProtocolHandler(BlobURLRequestJobTest* test) : test_(test) {}
// net::URLRequestJobFactory::ProtocolHandler override.
- virtual net::URLRequestJob* MaybeCreateJob(
+ net::URLRequestJob* MaybeCreateJob(
net::URLRequest* request,
- net::NetworkDelegate* network_delegate) const OVERRIDE {
+ net::NetworkDelegate* network_delegate) const override {
return new BlobURLRequestJob(request,
network_delegate,
test_->blob_data_.get(),
: blob_data_(new BlobData()),
expected_status_code_(0) {}
- virtual void SetUp() {
+ void SetUp() override {
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
temp_file1_ = temp_dir_.path().AppendASCII("BlobFile1.dat");
ASSERT_EQ(static_cast<int>(arraysize(kTestFileData1) - 1),
- file_util::WriteFile(temp_file1_, kTestFileData1,
+ base::WriteFile(temp_file1_, kTestFileData1,
arraysize(kTestFileData1) - 1));
base::File::Info file_info1;
base::GetFileInfo(temp_file1_, &file_info1);
temp_file2_ = temp_dir_.path().AppendASCII("BlobFile2.dat");
ASSERT_EQ(static_cast<int>(arraysize(kTestFileData2) - 1),
- file_util::WriteFile(temp_file2_, kTestFileData2,
+ base::WriteFile(temp_file2_, kTestFileData2,
arraysize(kTestFileData2) - 1));
base::File::Info file_info2;
base::GetFileInfo(temp_file2_, &file_info2);
url_request_context_.set_job_factory(&url_request_job_factory_);
}
- virtual void TearDown() {
- }
+ void TearDown() override {}
void SetUpFileSystem() {
// Prepare file system.
file_system_context_->OpenFileSystem(
GURL(kFileSystemURLOrigin),
kFileSystemType,
- fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+ storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
base::Bind(&BlobURLRequestJobTest::OnValidateFileSystem,
base::Unretained(this)));
base::RunLoop().RunUntilIdle();
void WriteFileSystemFile(const std::string& filename,
const char* buf, int buf_size,
base::Time* modification_time) {
- fileapi::FileSystemURL url =
+ storage::FileSystemURL url =
file_system_context_->CreateCrackedFileSystemURL(
GURL(kFileSystemURLOrigin),
kFileSystemType,
ASSERT_EQ(base::File::FILE_OK,
content::AsyncFileTestHelper::CreateFileWithData(
- file_system_context_, url, buf, buf_size));
+ file_system_context_.get(), url, buf, buf_size));
base::File::Info file_info;
ASSERT_EQ(base::File::FILE_OK,
content::AsyncFileTestHelper::GetMetadata(
- file_system_context_, url, &file_info));
+ file_system_context_.get(), url, &file_info));
if (modification_time)
*modification_time = file_info.last_modified;
}
void TestRequest(const std::string& method,
const net::HttpRequestHeaders& extra_headers) {
request_ = url_request_context_.CreateRequest(
- GURL("blob:blah"), net::DEFAULT_PRIORITY, &url_request_delegate_);
+ GURL("blob:blah"), net::DEFAULT_PRIORITY, &url_request_delegate_, NULL);
request_->set_method(method);
if (!extra_headers.IsEmpty())
request_->SetExtraRequestHeaders(extra_headers);
base::Time temp_file_system_file_modification_time2_;
base::MessageLoopForIO message_loop_;
- scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+ scoped_refptr<storage::FileSystemContext> file_system_context_;
scoped_refptr<BlobData> blob_data_;
net::URLRequestJobFactoryImpl url_request_job_factory_;
net::URLRequestContext url_request_context_;
}
TEST_F(BlobURLRequestJobTest, TestGetSimpleFileRequest) {
- blob_data_->AppendFile(temp_file1_, 0, -1, base::Time());
+ blob_data_->AppendFile(temp_file1_, 0, kuint64max, base::Time());
TestSuccessNonrangeRequest(kTestFileData1, arraysize(kTestFileData1) - 1);
}
for (int i = 0; i < kBufferSize * 5; ++i)
large_data.append(1, static_cast<char>(i % 256));
ASSERT_EQ(static_cast<int>(large_data.size()),
- file_util::WriteFile(large_temp_file, large_data.data(),
+ base::WriteFile(large_temp_file, large_data.data(),
large_data.size()));
- blob_data_->AppendFile(large_temp_file, 0, -1, base::Time());
+ blob_data_->AppendFile(large_temp_file, 0, kuint64max, base::Time());
TestSuccessNonrangeRequest(large_data, large_data.size());
}
TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileRequest) {
base::FilePath non_existent_file =
temp_file1_.InsertBeforeExtension(FILE_PATH_LITERAL("-na"));
- blob_data_->AppendFile(non_existent_file, 0, -1, base::Time());
+ blob_data_->AppendFile(non_existent_file, 0, kuint64max, base::Time());
TestErrorRequest(404);
}
TEST_F(BlobURLRequestJobTest, TestGetSimpleFileSystemFileRequest) {
SetUpFileSystem();
- blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, -1,
+ blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, kuint64max,
base::Time());
TestSuccessNonrangeRequest(kTestFileSystemFileData1,
arraysize(kTestFileSystemFileData1) - 1);
const char kFilename[] = "LargeBlob.dat";
WriteFileSystemFile(kFilename, large_data.data(), large_data.size(), NULL);
- blob_data_->AppendFileSystemFile(GetFileSystemURL(kFilename), 0, -1,
+ blob_data_->AppendFileSystemFile(GetFileSystemURL(kFilename), 0, kuint64max,
base::Time());
TestSuccessNonrangeRequest(large_data, large_data.size());
}
TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileSystemFileRequest) {
SetUpFileSystem();
GURL non_existent_file = GetFileSystemURL("non-existent.dat");
- blob_data_->AppendFileSystemFile(non_existent_file, 0, -1, base::Time());
+ blob_data_->AppendFileSystemFile(non_existent_file, 0, kuint64max,
+ base::Time());
TestErrorRequest(404);
}
projects / platform / framework / web / crosswalk.git / blobdiff