Use WeakPtr and do not use pointer equality in WebURLLoaderMockFactory

content/test/weburl_loader_mock_factory.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 "content/test/weburl_loader_mock_factory.h"
 
 #include <stdint.h>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
@@ skipping 58 matching lines @@
   url_to_reponse_info_.clear();
   url_to_error_info_.clear();
   WebCache::clear();
 }
 
 void WebURLLoaderMockFactory::ServeAsynchronousRequests() {
   // 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;
+    base::WeakPtr<WebURLLoaderMock> loader(iter->first->GetWeakPtr());
+    const WebURLRequest request = iter->second;
+    pending_loaders_.erase(loader.get());
+
     WebURLResponse response;
     WebURLError error;
     WebData data;
     LoadRequest(request, &response, &error, &data);
     // Follow any redirects while the loader is still active.
     while (response.httpStatusCode() >= 300 &&
            response.httpStatusCode() < 400) {
       WebURLRequest newRequest = loader->ServeRedirect(request, response);
-      if (!IsPending(loader) || loader->isDeferred())
+      if (!loader || loader->is_cancelled() || loader->is_deferred())
         break;
       LoadRequest(newRequest, &response, &error, &data);
     }
     // Serve the request if the loader is still active.
-    if (IsPending(loader) && !loader->isDeferred())
+    if (loader && !loader->is_cancelled() && !loader->is_deferred())
       loader->ServeAsynchronousRequest(delegate_, response, data, error);
-    // The loader might have already been removed.
-    pending_loaders_.erase(loader);
   }
   base::RunLoop().RunUntilIdle();
 }
 
 bool WebURLLoaderMockFactory::IsMockedURL(const blink::WebURL& url) {
   return url_to_reponse_info_.find(url) != url_to_reponse_info_.end();
 }
 
 void WebURLLoaderMockFactory::CancelLoad(WebURLLoaderMock* loader) {
   pending_loaders_.erase(loader);
@@ skipping 37 matching lines @@
   }
 
   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();
-}
-
 // static
 bool WebURLLoaderMockFactory::ReadFile(const base::FilePath& file_path,
                                        WebData* data) {
   // If the path is empty then we return an empty file so tests can simulate
   // requests without needing to actually load files.
   if (file_path.empty())
     return true;
 
   int64_t file_size = 0;
   if (!base::GetFileSize(file_path, &file_size))
     return false;
 
   int size = static_cast<int>(file_size);
   scoped_ptr<char[]> buffer(new char[size]);
   data->reset();
   int read_count = base::ReadFile(file_path, buffer.get(), size);
   if (read_count == -1)
     return false;
   DCHECK(read_count == size);
   data->assign(buffer.get(), size);
 
   return true;
 }