Remove a bunch of provisionalDataSource() usage.

components/test_runner/web_frame_test_proxy.h

 // Copyright 2014 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.
 
 #ifndef COMPONENTS_TEST_RUNNER_WEB_FRAME_TEST_PROXY_H_
 #define COMPONENTS_TEST_RUNNER_WEB_FRAME_TEST_PROXY_H_
 
 #include "base/basictypes.h"
 #include "components/test_runner/mock_screen_orientation_client.h"
 #include "components/test_runner/web_test_delegate.h"
@@ skipping 47 matching lines @@
   }
 
   virtual void loadURLExternally(blink::WebLocalFrame* frame,
                                  const blink::WebURLRequest& request,
                                  blink::WebNavigationPolicy policy,
                                  const blink::WebString& suggested_name) {
     base_proxy_->LoadURLExternally(frame, request, policy, suggested_name);
     Base::loadURLExternally(frame, request, policy, suggested_name);
   }
 
-  virtual void didStartProvisionalLoad(blink::WebLocalFrame* frame,
+  virtual void didStartProvisionalLoad(blink::WebDataSource* datasource,
                                        double triggeringEventTime) {
-    base_proxy_->DidStartProvisionalLoad(frame);
-    Base::didStartProvisionalLoad(
-        frame, triggeringEventTime);
+    base_proxy_->DidStartProvisionalLoad(Base::GetWebFrame());
+    Base::didStartProvisionalLoad(datasource, triggeringEventTime);
   }
 
   virtual void didReceiveServerRedirectForProvisionalLoad(
       blink::WebLocalFrame* frame) {
     base_proxy_->DidReceiveServerRedirectForProvisionalLoad(frame);
     Base::didReceiveServerRedirectForProvisionalLoad(frame);
   }
 
-  virtual void didFailProvisionalLoad(
-      blink::WebLocalFrame* frame,
-      const blink::WebURLError& error,
-      blink::WebHistoryCommitType commit_type) {
-    // If the test finished, don't notify the embedder of the failed load,
-    // as we already destroyed the document loader.
-    if (base_proxy_->DidFailProvisionalLoad(frame, error, commit_type))
-      return;
-    Base::didFailProvisionalLoad(frame, error, commit_type);
+  virtual void didFailProvisionalLoad(blink::WebDataSource* datasource,
+                                      const blink::WebURLError& error,
+                                      blink::WebHistoryCommitType commit_type) {
+    base_proxy_->DidFailProvisionalLoad(Base::GetWebFrame(), error,
+                                        commit_type);
+    Base::didFailProvisionalLoad(datasource, error, commit_type);
   }
 
   virtual void didCommitProvisionalLoad(
       blink::WebLocalFrame* frame,
       const blink::WebHistoryItem& item,
       blink::WebHistoryCommitType commit_type) {
     base_proxy_->DidCommitProvisionalLoad(frame, item, commit_type);
     Base::didCommitProvisionalLoad(frame, item, commit_type);
   }
 
@@ skipping 13 matching lines @@
   virtual void didFinishDocumentLoad(blink::WebLocalFrame* frame, bool empty) {
     base_proxy_->DidFinishDocumentLoad(frame);
     Base::didFinishDocumentLoad(frame, empty);
   }
 
   virtual void didHandleOnloadEvents(blink::WebLocalFrame* frame) {
     base_proxy_->DidHandleOnloadEvents(frame);
     Base::didHandleOnloadEvents(frame);
   }
 
-  virtual void didFailLoad(blink::WebLocalFrame* frame,
+  virtual void didFailLoad(blink::WebDataSource* datasource,
                            const blink::WebURLError& error,
                            blink::WebHistoryCommitType commit_type) {
-    base_proxy_->DidFailLoad(frame, error, commit_type);
-    Base::didFailLoad(frame, error, commit_type);
+    base_proxy_->DidFailLoad(Base::GetWebFrame(), error, commit_type);
+    Base::didFailLoad(datasource, error, commit_type);
   }
 
   virtual void didFinishLoad(blink::WebLocalFrame* frame) {
     Base::didFinishLoad(frame);
     base_proxy_->DidFinishLoad(frame);
   }
 
   virtual void didChangeSelection(bool is_selection_empty) {
     base_proxy_->DidChangeSelection(is_selection_empty);
     Base::didChangeSelection(is_selection_empty);
@@ skipping 55 matching lines @@
     // into the base proxy.
     base_proxy_->DidDispatchPingLoader(frame, url);
     Base::didDispatchPingLoader(frame, url);
   }
 
   virtual void didCreateDataSource(blink::WebLocalFrame* frame,
                                    blink::WebDataSource* ds) {
     Base::didCreateDataSource(frame, ds);
   }
 
-  virtual void willSendRequest(blink::WebLocalFrame* frame,
+  virtual void willSendRequest(blink::WebDataSource* datasource,
                                unsigned identifier,
                                blink::WebURLRequest& request,
                                const blink::WebURLResponse& redirect_response) {
-    Base::willSendRequest(frame, identifier, request, redirect_response);
-    base_proxy_->WillSendRequest(frame, identifier, request, redirect_response);
+    Base::willSendRequest(datasource, identifier, request, redirect_response);
+    base_proxy_->WillSendRequest(identifier, request, redirect_response);
   }
 
   virtual void didReceiveResponse(blink::WebLocalFrame* frame,
                                   unsigned identifier,
                                   const blink::WebURLResponse& response) {
     base_proxy_->DidReceiveResponse(frame, identifier, response);
     Base::didReceiveResponse(frame, identifier, response);
   }
 
   virtual void didChangeResourcePriority(
@@ skipping 60 matching lines @@
 
  private:
   WebTestProxyBase* base_proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(WebFrameTestProxy);
 };
 
 }  // namespace test_runner
 
 #endif  // COMPONENTS_TEST_RUNNER_WEB_FRAME_TEST_PROXY_H_