Move GetDocument method from WebFrame to WebLocalFrame.

content/renderer/dom_serializer_browsertest.cc

 // Copyright (c) 2010 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 92 matching lines @@
   }
 
   WebView* GetWebView() {
     return GetRenderView()->GetWebView();
   }
 
   WebLocalFrame* GetMainFrame() {
     return GetRenderView()->GetMainRenderFrame()->GetWebFrame();
   }
 
-  WebFrame* FindSubFrameByURL(const GURL& url) {
+  WebLocalFrame* FindSubFrameByURL(const GURL& url) {
     for (WebFrame* frame = GetWebView()->MainFrame(); frame;
          frame = frame->TraverseNext()) {
-      if (GURL(frame->GetDocument().Url()) == url)
-        return frame;
+      DCHECK(frame->IsWebLocalFrame());
+      if (GURL(frame->ToWebLocalFrame()->GetDocument().Url()) == url)
+        return frame->ToWebLocalFrame();
     }
     return nullptr;
   }
 
   // Load web page according to input content and relative URLs within
   // the document.
   void LoadContents(const std::string& contents,
                     const GURL& base_url,
                     const WebString encoding_info) {
     FrameLoadWaiter waiter(GetRenderView()->GetMainRenderFrame());
@@ skipping 43 matching lines @@
     WebString file_path = WebString::FromUTF8("c:\\dummy.htm");
     SingleLinkRewritingDelegate delegate(frame_url, file_path);
     // Start serializing DOM.
     bool result = WebFrameSerializer::Serialize(web_frame->ToWebLocalFrame(),
                                                 this, &delegate);
     ASSERT_TRUE(result);
   }
 
   void SerializeHTMLDOMWithDocTypeOnRenderer(const GURL& file_url) {
     // Make sure original contents have document type.
-    WebFrame* web_frame = FindSubFrameByURL(file_url);
+    WebLocalFrame* web_frame = FindSubFrameByURL(file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->GetDocument();
     ASSERT_TRUE(HasDocType(doc));
     // Do serialization.
     SerializeDomForURL(file_url);
     // Load the serialized contents.
     ASSERT_TRUE(serialization_reported_end_of_data_);
     LoadContents(serialized_contents_, file_url,
                  web_frame->GetDocument().Encoding());
     // Make sure serialized contents still have document type.
     web_frame = GetMainFrame();
     doc = web_frame->GetDocument();
     ASSERT_TRUE(HasDocType(doc));
   }
 
   void SerializeHTMLDOMWithoutDocTypeOnRenderer(const GURL& file_url) {
     // Make sure original contents do not have document type.
-    WebFrame* web_frame = FindSubFrameByURL(file_url);
+    WebLocalFrame* web_frame = FindSubFrameByURL(file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->GetDocument();
     ASSERT_TRUE(!HasDocType(doc));
     // Do serialization.
     SerializeDomForURL(file_url);
     // Load the serialized contents.
     ASSERT_TRUE(serialization_reported_end_of_data_);
     LoadContents(serialized_contents_, file_url,
                  web_frame->GetDocument().Encoding());
     // Make sure serialized contents do not have document type.
@@ skipping 25 matching lines @@
     SerializeDomForURL(file_url);
     // Make sure the serialized contents have MOTW ;
     ASSERT_TRUE(serialization_reported_end_of_data_);
     ASSERT_FALSE(std::string::npos ==
                  serialized_contents_.find(motw_declaration));
   }
 
   void SerializeHTMLDOMWithNoMetaCharsetInOriginalDocOnRenderer(
       const GURL& file_url) {
     // Make sure there is no META charset declaration in original document.
-    WebFrame* web_frame = FindSubFrameByURL(file_url);
+    WebLocalFrame* web_frame = FindSubFrameByURL(file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->GetDocument();
     ASSERT_TRUE(doc.IsHTMLDocument());
     WebElement head_element = doc.Head();
     ASSERT_TRUE(!head_element.IsNull());
     // Go through all children of HEAD element.
     WebElementCollection meta_elements =
         head_element.GetElementsByHTMLTagName("meta");
     for (WebElement element = meta_elements.FirstItem(); !element.IsNull();
          element = meta_elements.NextItem()) {
@@ skipping 28 matching lines @@
       if (element == meta_element)
         continue;
       ASSERT_TRUE(element.To<WebMetaElement>().ComputeEncoding().IsEmpty());
     }
   }
 
   void SerializeHTMLDOMWithMultipleMetaCharsetInOriginalDocOnRenderer(
       const GURL& file_url) {
     // Make sure there are multiple META charset declarations in original
     // document.
-    WebFrame* web_frame = FindSubFrameByURL(file_url);
+    WebLocalFrame* web_frame = FindSubFrameByURL(file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->GetDocument();
     ASSERT_TRUE(doc.IsHTMLDocument());
     WebElement head_element = doc.Head();
     ASSERT_TRUE(!head_element.IsNull());
     // Go through all children of HEAD element.
     int charset_declaration_count = 0;
     WebElementCollection meta_elements =
         head_element.GetElementsByHTMLTagName("meta");
     for (WebElement element = meta_elements.FirstItem(); !element.IsNull();
          element = meta_elements.NextItem()) {
       if (!element.To<WebMetaElement>().ComputeEncoding().IsEmpty())
         ++charset_declaration_count;
     }
     // The original doc has more than META tags which have charset declaration.
-    ASSERT_TRUE(charset_declaration_count > 1);
+    ASSERT_GT(charset_declaration_count, 1);
 
     // Do serialization.
     SerializeDomForURL(file_url);
 
     // Load the serialized contents.
     ASSERT_TRUE(serialization_reported_end_of_data_);
     LoadContents(serialized_contents_, file_url,
                  web_frame->GetDocument().Encoding());
     // Make sure only first child of HEAD element is META which has charset
     // declaration in serialized contents.
@@ skipping 27 matching lines @@
     // actions. The test content is in constant:original_contents.
     GURL file_url = net::FilePathToFileURL(page_file_path);
     ASSERT_TRUE(file_url.SchemeIsFile());
     // Test contents.
     static const char* const original_contents =
         "<html><body>&amp;&lt;&gt;\"\'</body></html>";
     // Load the test contents.
     LoadContents(original_contents, file_url, WebString());
 
     // Get BODY's text content in DOM.
-    WebFrame* web_frame = FindSubFrameByURL(file_url);
+    WebLocalFrame* web_frame = FindSubFrameByURL(file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->GetDocument();
     ASSERT_TRUE(doc.IsHTMLDocument());
     WebElement body_ele = doc.Body();
     ASSERT_TRUE(!body_ele.IsNull());
     WebNode text_node = body_ele.FirstChild();
     ASSERT_TRUE(text_node.IsTextNode());
-    ASSERT_TRUE(std::string(text_node.NodeValue().Utf8()) == "&<>\"\'");
+    ASSERT_EQ(text_node.NodeValue().Utf8(), "&<>\"\'");
     // Do serialization.
     SerializeDomForURL(file_url);
     // Compare the serialized contents with original contents.
     ASSERT_TRUE(serialization_reported_end_of_data_);
     // Compare the serialized contents with original contents to make sure
     // they are same.
     // Because we add MOTW when serializing DOM, so before comparison, we also
     // need to add MOTW to original_contents.
     std::string original_str =
         WebFrameSerializer::GenerateMarkOfTheWebDeclaration(file_url).Utf8();
@@ skipping 23 matching lines @@
     // Get file URL. The URL is dummy URL to identify the following loading
     // actions. The test content is in constant:original_contents.
     GURL file_url = net::FilePathToFileURL(page_file_path);
     ASSERT_TRUE(file_url.SchemeIsFile());
     // Test contents.
     static const char* const original_contents =
         "<html><body title=\"&amp;&lt;&gt;&quot;&#39;\"></body></html>";
     // Load the test contents.
     LoadContents(original_contents, file_url, WebString());
     // Get value of BODY's title attribute in DOM.
-    WebFrame* web_frame = FindSubFrameByURL(file_url);
+    WebLocalFrame* web_frame = FindSubFrameByURL(file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->GetDocument();
     ASSERT_TRUE(doc.IsHTMLDocument());
     WebElement body_ele = doc.Body();
     ASSERT_TRUE(!body_ele.IsNull());
     WebString value = body_ele.GetAttribute("title");
-    ASSERT_TRUE(std::string(value.Utf8()) == "&<>\"\'");
+    ASSERT_EQ(value.Utf8(), "&<>\"\'");
     // Do serialization.
     SerializeDomForURL(file_url);
     // Compare the serialized contents with original contents.
     ASSERT_TRUE(serialization_reported_end_of_data_);
     // Compare the serialized contents with original contents to make sure
     // they are same.
     std::string original_str =
         WebFrameSerializer::GenerateMarkOfTheWebDeclaration(file_url).Utf8();
     original_str += original_contents;
     if (!doc.IsNull()) {
       WebString encoding = web_frame->GetDocument().Encoding();
       std::string htmlTag("<html>");
       std::string::size_type pos = original_str.find(htmlTag);
       ASSERT_NE(std::string::npos, pos);
       pos += htmlTag.length();
       std::string head_part("<head>");
       head_part +=
           WebFrameSerializer::GenerateMetaCharsetDeclaration(encoding).Utf8();
       head_part += "</head>";
       original_str.insert(pos, head_part);
     }
     ASSERT_EQ(original_str, serialized_contents_);
   }
 
   void SerializeHTMLDOMWithNonStandardEntitiesOnRenderer(const GURL& file_url) {
     // Get value of BODY's title attribute in DOM.
-    WebFrame* web_frame = FindSubFrameByURL(file_url);
+    WebLocalFrame* web_frame = FindSubFrameByURL(file_url);
     WebDocument doc = web_frame->GetDocument();
     ASSERT_TRUE(doc.IsHTMLDocument());
     WebElement body_element = doc.Body();
     // Unescaped string for "&percnt;&nsup;&sup1;&apos;".
     static const wchar_t parsed_value[] = {
       '%', 0x2285, 0x00b9, '\'', 0
     };
     WebString value = body_element.GetAttribute("title");
     WebString content = doc.ContentAsTextForTesting();
     ASSERT_TRUE(base::UTF16ToWide(value.Utf16()) == parsed_value);
@@ skipping 11 matching lines @@
   }
 
   void SerializeHTMLDOMWithBaseTagOnRenderer(const GURL& file_url,
                                              const GURL& path_dir_url) {
     // There are total 2 available base tags in this test file.
     const int kTotalBaseTagCountInTestFile = 2;
 
     // Since for this test, we assume there is no savable sub-resource links for
     // this test file, also all links are relative URLs in this test file, so we
     // need to check those relative URLs and make sure document has BASE tag.
-    WebFrame* web_frame = FindSubFrameByURL(file_url);
+    WebLocalFrame* web_frame = FindSubFrameByURL(file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->GetDocument();
     ASSERT_TRUE(doc.IsHTMLDocument());
     // Go through all descent nodes.
     WebElementCollection all = doc.All();
     int original_base_tag_count = 0;
     for (WebElement element = all.FirstItem(); !element.IsNull();
          element = all.NextItem()) {
       if (element.HasHTMLTagName("base")) {
         original_base_tag_count++;
@@ skipping 70 matching lines @@
         "dom_serializer", "empty_head.htm");
     GURL file_url = net::FilePathToFileURL(page_file_path);
     ASSERT_TRUE(file_url.SchemeIsFile());
 
     // Load the test html content.
     static const char* const empty_head_contents =
       "<html><head></head><body>hello world</body></html>";
     LoadContents(empty_head_contents, file_url, WebString());
 
     // Make sure the head tag is empty.
-    WebFrame* web_frame = GetMainFrame();
+    WebLocalFrame* web_frame = GetMainFrame();
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->GetDocument();
     ASSERT_TRUE(doc.IsHTMLDocument());
     WebElement head_element = doc.Head();
     ASSERT_TRUE(!head_element.IsNull());
     ASSERT_TRUE(head_element.FirstChild().IsNull());
 
     // Do serialization.
     SerializeDomForURL(file_url);
     ASSERT_TRUE(serialization_reported_end_of_data_);
@@ skipping 19 matching lines @@
     // "hello world"
     WebElement body_element = doc.Body();
     ASSERT_TRUE(!body_element.IsNull());
     WebNode text_node = body_element.FirstChild();
     ASSERT_TRUE(text_node.IsTextNode());
     ASSERT_EQ("hello world", text_node.NodeValue());
   }
 
   void SubResourceForElementsInNonHTMLNamespaceOnRenderer(
       const GURL& file_url) {
-    WebFrame* web_frame = FindSubFrameByURL(file_url);
+    WebLocalFrame* web_frame = FindSubFrameByURL(file_url);
     ASSERT_TRUE(web_frame != NULL);
     WebDocument doc = web_frame->GetDocument();
     WebNode lastNodeInBody = doc.Body().LastChild();
     ASSERT_TRUE(lastNodeInBody.IsElementNode());
     WebString uri =
         GetSubResourceLinkFromElement(lastNodeInBody.To<WebElement>());
     EXPECT_TRUE(uri.IsNull());
   }
 
  private:
@@ skipping 231 matching lines @@
   NavigateToURL(shell(), file_url);
 
   PostTaskToInProcessRendererAndWait(
         base::Bind(
             &DomSerializerTests::
                 SubResourceForElementsInNonHTMLNamespaceOnRenderer,
             base::Unretained(this), file_url));
 }
 
 }  // namespace content