Move GetDocument method from WebFrame to WebLocalFrame.

content/renderer/savable_resources.cc

 // Copyright (c) 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/renderer/savable_resources.h"
 
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 19 matching lines @@
 using blink::WebNode;
 using blink::WebString;
 using blink::WebVector;
 using blink::WebView;
 
 namespace content {
 namespace {
 
 // Returns |true| if |web_frame| contains (or should be assumed to contain)
 // a html document.
-bool DoesFrameContainHtmlDocument(const WebFrame& web_frame,
+bool DoesFrameContainHtmlDocument(WebFrame* web_frame,
                                   const WebElement& element) {
-  if (web_frame.IsWebLocalFrame()) {
-    WebDocument doc = web_frame.GetDocument();
+  if (web_frame->IsWebLocalFrame()) {
+    WebDocument doc = web_frame->ToWebLocalFrame()->GetDocument();
     return doc.IsHTMLDocument() || doc.IsXHTMLDocument();
   }
 
   // Cannot inspect contents of a remote frame, so we use a heuristic:
   // Assume that <iframe> and <frame> elements contain a html document,
   // and other elements (i.e. <object>) contain plugins or other resources.
   // If the heuristic is wrong (i.e. the remote frame in <object> does
   // contain an html document), then things will still work, but with the
   // following caveats: 1) original frame content will be saved and 2) links
   // in frame's html doc will not be rewritten to point to locally saved
   // files.
   return element.HasHTMLTagName("iframe") || element.HasHTMLTagName("frame");
 }
 
 // If present and valid, then push the link associated with |element|
 // into either SavableResourcesResult::subframes or
 // SavableResourcesResult::resources_list.
 void GetSavableResourceLinkForElement(
     const WebElement& element,
     const WebDocument& current_doc,
     SavableResourcesResult* result) {
   // Get absolute URL.
   WebString link_attribute_value = GetSubResourceLinkFromElement(element);
   GURL element_url = current_doc.CompleteURL(link_attribute_value);
 
   // See whether to report this element as a subframe.
   WebFrame* web_frame = WebFrame::FromFrameOwnerElement(element);
-  if (web_frame && DoesFrameContainHtmlDocument(*web_frame, element)) {
+  if (web_frame && DoesFrameContainHtmlDocument(web_frame, element)) {
     SavableSubframe subframe;
     subframe.original_url = element_url;
     subframe.routing_id = RenderFrame::GetRoutingIdForWebFrame(web_frame);
     result->subframes->push_back(subframe);
     return;
   }
 
   // Check whether the node has sub resource URL or not.
   if (link_attribute_value.IsNull())
     return;
 
   // Ignore invalid URL.
   if (!element_url.is_valid())
     return;
 
   // Ignore those URLs which are not standard protocols. Because FTP
   // protocol does no have cache mechanism, we will skip all
   // sub-resources if they use FTP protocol.
   if (!element_url.SchemeIsHTTPOrHTTPS() &&
       !element_url.SchemeIs(url::kFileScheme))
     return;
 
   result->resources_list->push_back(element_url);
 }
 
 }  // namespace
 
-bool GetSavableResourceLinksForFrame(WebFrame* current_frame,
+bool GetSavableResourceLinksForFrame(WebLocalFrame* current_frame,
                                      SavableResourcesResult* result) {
   // Get current frame's URL.
   GURL current_frame_url = current_frame->GetDocument().Url();
 
   // If url of current frame is invalid, ignore it.
   if (!current_frame_url.is_valid())
     return false;
 
   // If url of current frame is not a savable protocol, ignore it.
   if (!IsSavableURL(current_frame_url))
@@ skipping 55 matching lines @@
   // otherwise return NULL.
   if (!value.IsNull() && !value.IsEmpty() &&
       !base::StartsWith(value.Utf8(),
                         "javascript:", base::CompareCase::INSENSITIVE_ASCII))
     return value;
 
   return WebString();
 }
 
 }  // namespace content