Drop test-only WebFrameClient params/functions

components/test_runner/web_frame_test_client.cc

 // Copyright 2016 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 "components/test_runner/web_frame_test_client.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
@@ skipping 78 matching lines @@
   if (response.isNull()) {
     delegate->PrintMessage("(null)");
     return;
   }
   delegate->PrintMessage(base::StringPrintf(
       "<NSURLResponse %s, http status code %d>",
       DescriptionSuitableForTestResult(response.url().string().utf8()).c_str(),
       response.httpStatusCode()));
 }
 
-std::string PriorityDescription(
-    const blink::WebURLRequest::Priority& priority) {
-  switch (priority) {
-    case blink::WebURLRequest::PriorityVeryLow:
-      return "VeryLow";
-    case blink::WebURLRequest::PriorityLow:
-      return "Low";
-    case blink::WebURLRequest::PriorityMedium:
-      return "Medium";
-    case blink::WebURLRequest::PriorityHigh:
-      return "High";
-    case blink::WebURLRequest::PriorityVeryHigh:
-      return "VeryHigh";
-    case blink::WebURLRequest::PriorityUnresolved:
-    default:
-      return "Unresolved";
-  }
-}
-
 void BlockRequest(blink::WebURLRequest& request) {
   request.setURL(GURL("255.255.255.255"));
 }
 
 bool IsLocalHost(const std::string& host) {
   return host == "127.0.0.1" || host == "localhost" || host == "[::1]";
 }
 
 bool IsTestHost(const std::string& host) {
   return base::EndsWith(host, ".test", base::CompareCase::INSENSITIVE_ASCII);
@@ skipping 394 matching lines @@
   if (test_runner_->shouldDumpFrameLoadCallbacks())
     delegate_->PrintMessage("didDetectXSS\n");
 }
 
 void WebFrameTestClient::didDispatchPingLoader(const blink::WebURL& url) {
   if (test_runner_->shouldDumpPingLoaderCallbacks())
     delegate_->PrintMessage(std::string("PingLoader dispatched to '") +
                             URLDescription(url).c_str() + "'.\n");
 }
 
-void WebFrameTestClient::willSendRequest(
-    blink::WebLocalFrame* frame,
-    unsigned identifier,
-    blink::WebURLRequest& request,
-    const blink::WebURLResponse& redirect_response) {
+void WebFrameTestClient::willSendRequest(blink::WebLocalFrame* frame,
+                                         blink::WebURLRequest& request) {
   // Need to use GURL for host() and SchemeIs()
   GURL url = request.url();
   std::string request_url = url.possibly_invalid_spec();
 
   GURL main_document_url = request.firstPartyForCookies();
 
-  if (redirect_response.isNull() &&
-      (test_runner_->shouldDumpResourceLoadCallbacks() ||
-       test_runner_->shouldDumpResourcePriorities())) {
-    DCHECK(resource_identifier_map_.find(identifier) ==
-           resource_identifier_map_.end());
-    resource_identifier_map_[identifier] =
-        DescriptionSuitableForTestResult(request_url);
-  }
-
   if (test_runner_->shouldDumpResourceLoadCallbacks()) {
-    if (resource_identifier_map_.find(identifier) ==
-        resource_identifier_map_.end())
-      delegate_->PrintMessage("<unknown>");
-    else
-      delegate_->PrintMessage(resource_identifier_map_[identifier]);
+    delegate_->PrintMessage(DescriptionSuitableForTestResult(request_url));
     delegate_->PrintMessage(" - willSendRequest <NSURLRequest URL ");
     delegate_->PrintMessage(
         DescriptionSuitableForTestResult(request_url).c_str());
     delegate_->PrintMessage(", main document URL ");
     delegate_->PrintMessage(URLDescription(main_document_url).c_str());
     delegate_->PrintMessage(", http method ");
     delegate_->PrintMessage(request.httpMethod().utf8().data());
-    delegate_->PrintMessage("> redirectResponse ");
-    PrintResponseDescription(delegate_, redirect_response);
-    delegate_->PrintMessage("\n");
-  }
-
-  if (test_runner_->shouldDumpResourcePriorities()) {
-    delegate_->PrintMessage(
-        DescriptionSuitableForTestResult(request_url).c_str());
-    delegate_->PrintMessage(" has priority ");
-    delegate_->PrintMessage(PriorityDescription(request.getPriority()));
-    delegate_->PrintMessage("\n");
+    delegate_->PrintMessage(">\n");
   }
 
   if (test_runner_->httpHeadersToClear()) {
     const std::set<std::string>* clearHeaders =
         test_runner_->httpHeadersToClear();
     for (std::set<std::string>::const_iterator header = clearHeaders->begin();
          header != clearHeaders->end(); ++header)
       request.clearHTTPHeaderField(blink::WebString::fromUTF8(*header));
   }
 
@@ skipping 13 matching lines @@
     }
   }
 
   // Set the new substituted URL.
   request.setURL(delegate_->RewriteLayoutTestsURL(
       request.url().string().utf8(),
       test_runner_->is_web_platform_tests_mode()));
 }
 
 void WebFrameTestClient::didReceiveResponse(
-    unsigned identifier,
     const blink::WebURLResponse& response) {
   if (test_runner_->shouldDumpResourceLoadCallbacks()) {
-    if (resource_identifier_map_.find(identifier) ==
-        resource_identifier_map_.end())
-      delegate_->PrintMessage("<unknown>");
-    else
-      delegate_->PrintMessage(resource_identifier_map_[identifier]);
+    delegate_->PrintMessage(DescriptionSuitableForTestResult(
+        GURL(response.url()).possibly_invalid_spec()));
     delegate_->PrintMessage(" - didReceiveResponse ");
     PrintResponseDescription(delegate_, response);
     delegate_->PrintMessage("\n");
   }
   if (test_runner_->shouldDumpResourceResponseMIMETypes()) {
     GURL url = response.url();
     blink::WebString mime_type = response.mimeType();
     delegate_->PrintMessage(url.ExtractFileName());
     delegate_->PrintMessage(" has MIME type ");
     // Simulate NSURLResponse's mapping of empty/unknown MIME types to
     // application/octet-stream
     delegate_->PrintMessage(mime_type.isEmpty() ? "application/octet-stream"
                                                 : mime_type.utf8().data());
     delegate_->PrintMessage("\n");
   }
 }
 
-void WebFrameTestClient::didChangeResourcePriority(
-    unsigned identifier,
-    const blink::WebURLRequest::Priority& priority,
-    int intra_priority_value) {
-  if (test_runner_->shouldDumpResourcePriorities()) {
-    if (resource_identifier_map_.find(identifier) ==
-        resource_identifier_map_.end())
-      delegate_->PrintMessage("<unknown>");
-    else
-      delegate_->PrintMessage(resource_identifier_map_[identifier]);
-    delegate_->PrintMessage(base::StringPrintf(
-        " changed priority to %s, intra_priority %d\n",
-        PriorityDescription(priority).c_str(), intra_priority_value));
-  }
-}
-
-void WebFrameTestClient::didFinishResourceLoad(blink::WebLocalFrame* frame,
-                                               unsigned identifier) {
-  if (test_runner_->shouldDumpResourceLoadCallbacks()) {
-    if (resource_identifier_map_.find(identifier) ==
-        resource_identifier_map_.end())
-      delegate_->PrintMessage("<unknown>");
-    else
-      delegate_->PrintMessage(resource_identifier_map_[identifier]);
-    delegate_->PrintMessage(" - didFinishLoading\n");
-  }
-  resource_identifier_map_.erase(identifier);
-}
-
 void WebFrameTestClient::didAddMessageToConsole(
     const blink::WebConsoleMessage& message,
     const blink::WebString& source_name,
     unsigned source_line,
     const blink::WebString& stack_trace) {
   if (!test_runner_->ShouldDumpConsoleMessages())
     return;
   std::string level;
   switch (message.level) {
     case blink::WebConsoleMessage::LevelDebug:
@@ skipping 82 matching lines @@
 
 bool WebFrameTestClient::runFileChooser(
     const blink::WebFileChooserParams& params,
     blink::WebFileChooserCompletion* completion) {
   delegate_->PrintMessage("Mock: Opening a file chooser.\n");
   // FIXME: Add ability to set file names to a file upload control.
   return false;
 }
 
 }  // namespace test_runner