Failure in reading Blob URL should results in network error

content/browser/blob_storage/blob_url_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 <stdint.h>
 
 #include <limits>
 #include <memory>
 
 #include "base/bind.h"
@@ skipping 140 matching lines @@
     }
 
    private:
     BlobURLRequestJobTest* test_;
   };
 
   BlobURLRequestJobTest()
       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         blob_data_(new BlobDataBuilder("uuid")),
         response_error_code_(net::OK),
+        expected_error_code_(net::OK),
         expected_status_code_(0) {}
 
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     temp_file1_ = temp_dir_.GetPath().AppendASCII("BlobFile1.dat");
     ASSERT_EQ(static_cast<int>(arraysize(kTestFileData1) - 1),
               base::WriteFile(temp_file1_, kTestFileData1,
                               arraysize(kTestFileData1) - 1));
     base::File::Info file_info1;
@@ skipping 78 matching lines @@
   void OnValidateFileSystem(const GURL& root,
                             const std::string& name,
                             base::File::Error result) {
     ASSERT_EQ(base::File::FILE_OK, result);
     ASSERT_TRUE(root.is_valid());
     file_system_root_url_ = root;
   }
 
   void TestSuccessNonrangeRequest(const std::string& expected_response,
                                   int64_t expected_content_length) {
+    expected_error_code_ = net::OK;
     expected_status_code_ = 200;
     expected_response_ = expected_response;
     TestRequest("GET", net::HttpRequestHeaders());
     EXPECT_EQ(expected_content_length, response_headers_->GetContentLength());
   }
 
-  void TestErrorRequest(int expected_status_code) {
-    expected_status_code_ = expected_status_code;
+  void TestErrorRequest(int expected_error_code) {
+    expected_error_code_ = expected_error_code;
     expected_response_ = "";
     TestRequest("GET", net::HttpRequestHeaders());
     EXPECT_TRUE(response_metadata_.empty());
   }
 
   void TestRequest(const std::string& method,
                    const net::HttpRequestHeaders& extra_headers) {
     GURL url("blob:blah");
 
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 42 matching lines @@
       if (request->response_info().metadata) {
         response_metadata_ =
             std::string(request->response_info().metadata->data(),
                         request->response_info().metadata->size());
       }
 
       response_error_code_ = url_request_delegate_.request_status();
     }
 
     // Verify response.
-    EXPECT_EQ(net::OK, response_error_code_);
-    EXPECT_EQ(expected_status_code_, response_headers_->response_code());
-    EXPECT_EQ(expected_response_, response_);
+    EXPECT_EQ(expected_error_code_, response_error_code_);
+    if (response_error_code_ == net::OK) {
+      EXPECT_EQ(expected_status_code_, response_headers_->response_code());
+      EXPECT_EQ(expected_response_, response_);
+    }
   }
 
   void BuildComplicatedData(std::string* expected_result) {
     blob_data_->AppendData(kTestData1 + 1, 2);
     *expected_result = std::string(kTestData1 + 1, 2);
 
     blob_data_->AppendFile(temp_file1_, 2, 3, temp_file_modification_time1_);
     *expected_result += std::string(kTestFileData1 + 2, 3);
 
     blob_data_->AppendDiskCacheEntry(new EmptyDataHandle(),
@@ skipping 65 matching lines @@
   std::unique_ptr<BlobDataBuilder> blob_data_;
   std::unique_ptr<BlobDataSnapshot> blob_data_snapshot_;
   net::URLRequestJobFactoryImpl url_request_job_factory_;
   net::URLRequestContext url_request_context_;
   net::TestDelegate url_request_delegate_;
   std::string response_;
   int response_error_code_;
   scoped_refptr<net::HttpResponseHeaders> response_headers_;
   std::string response_metadata_;
 
+  int expected_error_code_;
   int expected_status_code_;
   std::string expected_response_;
 };
 
 TEST_F(BlobURLRequestJobTest, TestGetSimpleDataRequest) {
   blob_data_->AppendData(kTestData1);
   TestSuccessNonrangeRequest(kTestData1, arraysize(kTestData1) - 1);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileRequest) {
@@ skipping 15 matching lines @@
   blob_data_->AppendFile(large_temp_file, 0,
                          std::numeric_limits<uint64_t>::max(), 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,
                          std::numeric_limits<uint64_t>::max(), base::Time());
-  TestErrorRequest(404);
+  TestErrorRequest(net::ERR_FILE_NOT_FOUND);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetChangedFileRequest) {
   base::Time old_time =
       temp_file_modification_time1_ - base::TimeDelta::FromSeconds(10);
   blob_data_->AppendFile(temp_file1_, 0, 3, old_time);
-  TestErrorRequest(404);
+  TestErrorRequest(net::ERR_FILE_NOT_FOUND);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileRequest) {
   blob_data_->AppendFile(temp_file1_, 2, 4, temp_file_modification_time1_);
   std::string result(kTestFileData1 + 2, 4);
   TestSuccessNonrangeRequest(result, 4);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileSystemFileRequest) {
   SetUpFileSystem();
@@ skipping 18 matching lines @@
                                    std::numeric_limits<uint64_t>::max(),
                                    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, std::numeric_limits<uint64_t>::max(), base::Time());
-  TestErrorRequest(404);
+  TestErrorRequest(net::ERR_FILE_NOT_FOUND);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetInvalidFileSystemFileRequest) {
   SetUpFileSystem();
   GURL invalid_file;
   blob_data_->AppendFileSystemFile(
       invalid_file, 0, std::numeric_limits<uint64_t>::max(), base::Time());
-  TestErrorRequest(500);
+  TestErrorRequest(net::ERR_FAILED);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetChangedFileSystemFileRequest) {
   SetUpFileSystem();
   base::Time old_time = temp_file_system_file_modification_time1_ -
                         base::TimeDelta::FromSeconds(10);
   blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, 3, old_time);
-  TestErrorRequest(404);
+  TestErrorRequest(net::ERR_FILE_NOT_FOUND);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileSystemFileRequest) {
   SetUpFileSystem();
   blob_data_->AppendFileSystemFile(temp_file_system_file1_, 2, 4,
                                    temp_file_system_file_modification_time1_);
   std::string result(kTestFileSystemFileData1 + 2, 4);
   TestSuccessNonrangeRequest(result, 4);
 }
 
@@ skipping 125 matching lines @@
   TestRequest("GET", net::HttpRequestHeaders());
   EXPECT_EQ(static_cast<int>(arraysize(kTestDiskCacheData2) - 1),
             response_headers_->GetContentLength());
 
   EXPECT_TRUE(response_metadata_.empty());
 }
 
 TEST_F(BlobURLRequestJobTest, BrokenBlob) {
   blob_handle_ = blob_context_.AddBrokenBlob(
       "uuid", "", "", storage::BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS);
-  TestErrorRequest(500);
+  TestErrorRequest(net::ERR_FAILED);
 }
 
 }  // namespace content