Add support for mocking failed loads to WebURLLoaderMock.

webkit/support/weburl_loader_mock_factory.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 "webkit/support/weburl_loader_mock_factory.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLError.h"
@@ skipping 32 matching lines @@
     response_info.file_path =
         FilePath(std::wstring(file_path.data(), file_path.length()));
 #endif
     DCHECK(file_util::PathExists(response_info.file_path));
   }
 
   DCHECK(url_to_reponse_info_.find(url) == url_to_reponse_info_.end());
   url_to_reponse_info_[url] = response_info;
 }
 
+
+void WebURLLoaderMockFactory::RegisterErrorURL(const WebURL& url,
+                                               const WebURLResponse& response,
+                                               const WebURLError& error) {
+  DCHECK(url_to_reponse_info_.find(url) == url_to_reponse_info_.end());
+  RegisterURL(url, response, WebString());
+  url_to_error_info_[url] = error;
+}
+
 void WebURLLoaderMockFactory::UnregisterURL(const WebKit::WebURL& url) {
   URLToResponseMap::iterator iter = url_to_reponse_info_.find(url);
   DCHECK(iter != url_to_reponse_info_.end());
   url_to_reponse_info_.erase(iter);
+
+  URLToErrorMap::iterator error_iter = url_to_error_info_.find(url);
+  if (error_iter != url_to_error_info_.end())
+    url_to_error_info_.erase(error_iter);
 }
 
 void WebURLLoaderMockFactory::UnregisterAllURLs() {
   url_to_reponse_info_.clear();
+  url_to_error_info_.clear();
 }
 
 void WebURLLoaderMockFactory::ServeAsynchronousRequests() {
   last_handled_asynchronous_request_.reset();
   // Serving a request might trigger more requests, so we cannot iterate on
   // pending_loaders_ as it might get modified.
   while (!pending_loaders_.empty()) {
     LoaderToRequestMap::iterator iter = pending_loaders_.begin();
     WebURLLoaderMock* loader = iter->first;
     const WebURLRequest& request = iter->second;
@@ skipping 51 matching lines @@
                                                 WebURLLoaderMock* loader) {
   LoaderToRequestMap::iterator iter = pending_loaders_.find(loader);
   DCHECK(iter == pending_loaders_.end());
   pending_loaders_[loader] = request;
 }
 
 void WebURLLoaderMockFactory::LoadRequest(const WebURLRequest& request,
                                           WebURLResponse* response,
                                           WebURLError* error,
                                           WebData* data) {
+  URLToErrorMap::const_iterator error_iter =
+      url_to_error_info_.find(request.url());
+  if (error_iter != url_to_error_info_.end())
+    *error = error_iter->second;
+
   URLToResponseMap::const_iterator iter =
       url_to_reponse_info_.find(request.url());
   if (iter == url_to_reponse_info_.end()) {
     // Non mocked URLs should not have been passed to the default URLLoader.
     NOTREACHED();
     return;
   }
 
-  if (!ReadFile(iter->second.file_path, data)) {
+  if (!error->reason && !ReadFile(iter->second.file_path, data)) {
     NOTREACHED();
     return;
   }
 
   *response = iter->second.response;
 }
 
 bool WebURLLoaderMockFactory::IsPending(WebURLLoaderMock* loader) {
   LoaderToRequestMap::iterator iter = pending_loaders_.find(loader);
   return iter != pending_loaders_.end();
@@ skipping 10 matching lines @@
   scoped_array<char> buffer(new char[size]);
   data->reset();
   int read_count = file_util::ReadFile(file_path, buffer.get(), size);
   if (read_count == -1)
     return false;
   DCHECK(read_count == size);
   data->assign(buffer.get(), size);
 
   return true;
 }