Added URLRequestContext to constructor for URLRequest.

webkit/fileapi/file_writer_delegate_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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/io_buffer.h"
 #include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/platform_test.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_writer_delegate.h"
 #include "webkit/fileapi/sandbox_file_stream_writer.h"
 
 namespace fileapi {
@@ skipping 84 matching lines @@
   }
 
   // Creates and sets up a FileWriterDelegate for writing the given |blob_url|,
   // and creates a new FileWriterDelegate for the file.
   void PrepareForWrite(const GURL& blob_url,
                        int64 offset,
                        int64 allowed_growth) {
     result_.reset(new Result());
     file_writer_delegate_.reset(
         CreateWriterDelegate("test", offset, allowed_growth, result_.get()));
-    request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
+    request_.reset(new net::URLRequest(blob_url,
+                                       file_writer_delegate_.get(),
+                                       &empty_context_));
   }
 
   static net::URLRequest::ProtocolFactory Factory;
 
   // This should be alive until the very end of this instance.
   MessageLoop loop_;
 
+  net::URLRequestContext empty_context_;
   scoped_ptr<FileWriterDelegate> file_writer_delegate_;
   scoped_ptr<net::URLRequest> request_;
   scoped_ptr<Result> result_;
   FileSystemTestOriginHelper test_helper_;
 
   ScopedTempDir dir_;
 
   static const char* content_;
 };
 
@@ skipping 198 matching lines @@
   const GURL kBlobURL("blob:nolimitconcurrent");
   const GURL kBlobURL2("blob:nolimitconcurrent2");
   content_ = kData;
 
   PrepareForWrite(kBlobURL, 0, quota::QuotaManager::kNoLimit);
 
   // Credate another FileWriterDelegate for concurrent write.
   result2.reset(new Result());
   file_writer_delegate2.reset(CreateWriterDelegate(
       "test2", 0, quota::QuotaManager::kNoLimit, result2.get()));
-  request2.reset(new net::URLRequest(kBlobURL2, file_writer_delegate2.get()));
+  request2.reset(new net::URLRequest(kBlobURL2,
+                                     file_writer_delegate2.get(),
+                                     &empty_context_));
 
   ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
   file_writer_delegate_->Start(request_.Pass());
   file_writer_delegate2->Start(request2.Pass());
   MessageLoop::current()->Run();
   if (!result_->complete() || !result2->complete())
     MessageLoop::current()->Run();
 
   ASSERT_TRUE(result_->complete());
   ASSERT_TRUE(result2->complete());
@@ skipping 97 matching lines @@
   file_writer_delegate_.reset();
 
   EXPECT_EQ(pre_write_usage + allowed_growth,
             test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(kOverlap + allowed_growth, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result_->status());
 }
 
 }  // namespace fileapi