Add FilePath to base namespace.

webkit/glue/dom_serializer_unittest.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 "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/hash_tables.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 187 matching lines @@
   SerializationFinishStatusMap serialization_finish_status_;
   // Flag indicates whether the process of serializing DOM is finished or not.
   bool serialized_;
   // The links_ contain dummy original URLs of all saved links.
   WebVector<WebURL> links_;
   // The local_paths_ contain dummy corresponding local file paths of all saved
   // links, which matched links_ one by one.
   WebVector<WebString> local_paths_;
   // The local_directory_name_ is dummy relative path of directory which
   // contain all saved auxiliary files included all sub frames and resources.
-  const FilePath local_directory_name_;
+  const base::FilePath local_directory_name_;
 
  protected:
   // testing::Test
   virtual void SetUp() {
     TestShellTest::SetUp();
     serialized_ = false;
   }
 
   virtual void TearDown() {
     TestShellTest::TearDown();
@@ skipping 57 matching lines @@
       charset_info = content.substr(start_pos, end_pos - start_pos);
       return true;
     }
   }
   return true;
 }
 
 // If original contents have document type, the serialized contents also have
 // document type.
 TEST_F(DomSerializerTests, SerializeHTMLDOMWithDocType) {
-  FilePath page_file_path = data_dir_;
+  base::FilePath page_file_path = data_dir_;
   page_file_path = page_file_path.AppendASCII("dom_serializer");
   page_file_path = page_file_path.AppendASCII("youtube_1.htm");
   GURL file_url = net::FilePathToFileURL(page_file_path);
   ASSERT_TRUE(file_url.SchemeIsFile());
   // Load the test file.
   LoadPageFromURL(file_url);
   // Make sure original contents have document type.
   WebFrame* web_frame = FindSubFrameByURL(test_shell_->webView(), file_url);
   ASSERT_TRUE(web_frame != NULL);
   WebDocument doc = web_frame->document();
   ASSERT_TRUE(HasDocType(doc));
   // Do serialization.
   SerializeDomForURL(file_url, false);
   // Load the serialized contents.
   ASSERT_TRUE(HasSerializedFrame(file_url));
   const std::string& serialized_contents =
       GetSerializedContentForFrame(file_url);
   LoadContents(serialized_contents, file_url,
                web_frame->document().encoding());
   // Make sure serialized contents still have document type.
   web_frame = test_shell_->webView()->mainFrame();
   doc = web_frame->document();
   ASSERT_TRUE(HasDocType(doc));
 }
 
 // If original contents do not have document type, the serialized contents
 // also do not have document type.
 TEST_F(DomSerializerTests, SerializeHTMLDOMWithoutDocType) {
-  FilePath page_file_path = data_dir_;
+  base::FilePath page_file_path = data_dir_;
   page_file_path = page_file_path.AppendASCII("dom_serializer");
   page_file_path = page_file_path.AppendASCII("youtube_2.htm");
   GURL file_url = net::FilePathToFileURL(page_file_path);
   ASSERT_TRUE(file_url.SchemeIsFile());
   // Load the test file.
   LoadPageFromURL(file_url);
   // Make sure original contents do not have document type.
   WebFrame* web_frame = FindSubFrameByURL(test_shell_->webView(), file_url);
   ASSERT_TRUE(web_frame != NULL);
   WebDocument doc = web_frame->document();
   ASSERT_TRUE(!HasDocType(doc));
   // Do serialization.
   SerializeDomForURL(file_url, false);
   // Load the serialized contents.
   ASSERT_TRUE(HasSerializedFrame(file_url));
   const std::string& serialized_contents =
       GetSerializedContentForFrame(file_url);
   LoadContents(serialized_contents, file_url,
                web_frame->document().encoding());
   // Make sure serialized contents do not have document type.
   web_frame = test_shell_->webView()->mainFrame();
   doc = web_frame->document();
   ASSERT_TRUE(!HasDocType(doc));
 }
 
 // Serialize XML document which has all 5 built-in entities. After
 // finishing serialization, the serialized contents should be same
 // with original XML document.
 TEST_F(DomSerializerTests, SerializeXMLDocWithBuiltInEntities) {
-  FilePath page_file_path = data_dir_;
+  base::FilePath page_file_path = data_dir_;
   page_file_path = page_file_path.AppendASCII("dom_serializer");
   page_file_path = page_file_path.AppendASCII("note.xml");
   // Read original contents for later comparison.
   std::string original_contents;
   ASSERT_TRUE(file_util::ReadFileToString(page_file_path, &original_contents));
   // Get file URL.
   GURL file_url = net::FilePathToFileURL(page_file_path);
   ASSERT_TRUE(file_url.SchemeIsFile());
   // Load the test file.
   LoadPageFromURL(file_url);
   // Do serialization.
   SerializeDomForURL(file_url, false);
   // Compare the serialized contents with original contents.
   ASSERT_TRUE(HasSerializedFrame(file_url));
   const std::string& serialized_contents =
       GetSerializedContentForFrame(file_url);
   ASSERT_EQ(original_contents, serialized_contents);
 }
 
 // When serializing DOM, we add MOTW declaration before html tag.
 TEST_F(DomSerializerTests, SerializeHTMLDOMWithAddingMOTW) {
-  FilePath page_file_path = data_dir_;
+  base::FilePath page_file_path = data_dir_;
   page_file_path = page_file_path.AppendASCII("dom_serializer");
   page_file_path = page_file_path.AppendASCII("youtube_2.htm");
   // Read original contents for later comparison .
   std::string original_contents;
   ASSERT_TRUE(file_util::ReadFileToString(page_file_path, &original_contents));
   // Get file URL.
   GURL file_url = net::FilePathToFileURL(page_file_path);
   ASSERT_TRUE(file_url.SchemeIsFile());
   // Make sure original contents does not have MOTW;
   std::string motw_declaration =
@@ skipping 13 matching lines @@
       GetSerializedContentForFrame(file_url);
   ASSERT_FALSE(std::string::npos ==
       serialized_contents.find(motw_declaration));
 }
 
 // When serializing DOM, we will add the META which have correct charset
 // declaration as first child of HEAD element for resolving WebKit bug:
 // http://bugs.webkit.org/show_bug.cgi?id=16621 even the original document
 // does not have META charset declaration.
 TEST_F(DomSerializerTests, SerializeHTMLDOMWithNoMetaCharsetInOriginalDoc) {
-  FilePath page_file_path = data_dir_;
+  base::FilePath page_file_path = data_dir_;
   page_file_path = page_file_path.AppendASCII("dom_serializer");
   page_file_path = page_file_path.AppendASCII("youtube_1.htm");
   // Get file URL.
   GURL file_url = net::FilePathToFileURL(page_file_path);
   ASSERT_TRUE(file_url.SchemeIsFile());
   // Load the test file.
   LoadPageFromURL(file_url);
 
   // Make sure there is no META charset declaration in original document.
   WebFrame* web_frame = FindSubFrameByURL(test_shell_->webView(), file_url);
@@ skipping 43 matching lines @@
       ASSERT_TRUE(charset_info.empty());
   }
 }
 
 // When serializing DOM, if the original document has multiple META charset
 // declaration, we will add the META which have correct charset declaration
 // as first child of HEAD element and remove all original META charset
 // declarations.
 TEST_F(DomSerializerTests,
        SerializeHTMLDOMWithMultipleMetaCharsetInOriginalDoc) {
-  FilePath page_file_path = data_dir_;
+  base::FilePath page_file_path = data_dir_;
   page_file_path = page_file_path.AppendASCII("dom_serializer");
   page_file_path = page_file_path.AppendASCII("youtube_2.htm");
   // Get file URL.
   GURL file_url = net::FilePathToFileURL(page_file_path);
   ASSERT_TRUE(file_url.SchemeIsFile());
   // Load the test file.
   LoadPageFromURL(file_url);
 
   // Make sure there are multiple META charset declarations in original
   // document.
@@ skipping 44 matching lines @@
   for (WebNode child = meta_node.nextSibling(); !child.isNull();
        child = child.nextSibling()) {
     std::string charset_info;
     if (IsMetaElement(child, charset_info))
       ASSERT_TRUE(charset_info.empty());
   }
 }
 
 // Test situation of html entities in text when serializing HTML DOM.
 TEST_F(DomSerializerTests, SerializeHTMLDOMWithEntitiesInText) {
-  FilePath page_file_path = data_dir_;
+  base::FilePath page_file_path = data_dir_;
   page_file_path = page_file_path.AppendASCII(
       "dom_serializer/htmlentities_in_text.htm");
   // 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>&amp;&lt;&gt;\"\'</body></html>";
   // Load the test contents.
@@ skipping 39 matching lines @@
     head_part += "</head>";
     original_str.insert(pos, head_part);
   }
   ASSERT_EQ(original_str, serialized_contents);
 }
 
 // Test situation of html entities in attribute value when serializing
 // HTML DOM.
 // This test started to fail at WebKit r65388. See http://crbug.com/52279.
 TEST_F(DomSerializerTests, SerializeHTMLDOMWithEntitiesInAttributeValue) {
-  FilePath page_file_path = data_dir_;
+  base::FilePath page_file_path = data_dir_;
   page_file_path = page_file_path.AppendASCII(
       "dom_serializer/htmlentities_in_attribute_value.htm");
   // 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.
@@ skipping 30 matching lines @@
     head_part += "</head>";
     original_str.insert(pos, head_part);
   }
   ASSERT_EQ(original_str, serialized_contents);
 }
 
 // Test situation of non-standard HTML entities when serializing HTML DOM.
 // This test started to fail at WebKit r65351. See http://crbug.com/52279.
 TEST_F(DomSerializerTests, SerializeHTMLDOMWithNonStandardEntities) {
   // Make a test file URL and load it.
-  FilePath page_file_path = data_dir_;
+  base::FilePath page_file_path = data_dir_;
   page_file_path = page_file_path.AppendASCII("dom_serializer");
   page_file_path = page_file_path.AppendASCII("nonstandard_htmlentities.htm");
   GURL file_url = net::FilePathToFileURL(page_file_path);
   LoadPageFromURL(file_url);
 
   // Get value of BODY's title attribute in DOM.
   WebFrame* web_frame = FindSubFrameByURL(test_shell_->webView(), file_url);
   WebDocument doc = web_frame->document();
   ASSERT_TRUE(doc.isHTMLDocument());
   WebElement body_element = doc.body();
@@ skipping 19 matching lines @@
 }
 
 // Test situation of BASE tag in original document when serializing HTML DOM.
 // When serializing, we should comment the BASE tag, append a new BASE tag.
 // rewrite all the savable URLs to relative local path, and change other URLs
 // to absolute URLs.
 TEST_F(DomSerializerTests, SerializeHTMLDOMWithBaseTag) {
   // There are total 2 available base tags in this test file.
   const int kTotalBaseTagCountInTestFile = 2;
 
-  FilePath page_file_path = data_dir_.AppendASCII("dom_serializer");
+  base::FilePath page_file_path = data_dir_.AppendASCII("dom_serializer");
   file_util::EnsureEndsWithSeparator(&page_file_path);
 
   // Get page dir URL which is base URL of this file.
   GURL path_dir_url = net::FilePathToFileURL(page_file_path);
   // Get file path.
   page_file_path =
       page_file_path.AppendASCII("html_doc_has_base_tag.htm");
   // Get file URL.
   GURL file_url = net::FilePathToFileURL(page_file_path);
   ASSERT_TRUE(file_url.SchemeIsFile());
@@ skipping 83 matching lines @@
   }
   // We have one more added BASE tag which is generated by JavaScript.
   ASSERT_EQ(new_base_tag_count, original_base_tag_count + 1);
   // Make sure in new document, the base URL is equal with the |path_dir_url|.
   GURL new_base_url(doc.baseURL());
   ASSERT_EQ(new_base_url, path_dir_url);
 }
 
 // Serializing page which has an empty HEAD tag.
 TEST_F(DomSerializerTests, SerializeHTMLDOMWithEmptyHead) {
-  FilePath page_file_path = data_dir_;
+  base::FilePath page_file_path = data_dir_;
   page_file_path = page_file_path.AppendASCII("dom_serializer");
   page_file_path = page_file_path.AppendASCII("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());
 
@@ skipping 39 matching lines @@
   ASSERT_TRUE(!body_element.isNull());
   WebNode text_node = body_element.firstChild();
   ASSERT_TRUE(text_node.isTextNode());
   WebString text_node_contents = text_node.nodeValue();
   ASSERT_TRUE(std::string(text_node_contents.utf8()) == "hello world");
 }
 
 // Test that we don't crash when the page contains an iframe that
 // was handled as a download (http://crbug.com/42212).
 TEST_F(DomSerializerTests, SerializeDocumentWithDownloadedIFrame) {
-  FilePath page_file_path = data_dir_;
+  base::FilePath page_file_path = data_dir_;
   page_file_path = page_file_path.AppendASCII("dom_serializer");
   page_file_path = page_file_path.AppendASCII("iframe-src-is-exe.htm");
   GURL file_url = net::FilePathToFileURL(page_file_path);
   ASSERT_TRUE(file_url.SchemeIsFile());
   // Load the test file.
   LoadPageFromURL(file_url);
   // Do a recursive serialization. We pass if we don't crash.
   SerializeDomForURL(file_url, true);
 }
 
 TEST_F(DomSerializerTests, SubResourceForElementsInNonHTMLNamespace) {
-  FilePath page_file_path = data_dir_;
+  base::FilePath page_file_path = data_dir_;
   page_file_path = page_file_path.AppendASCII("dom_serializer");
   page_file_path = page_file_path.AppendASCII("non_html_namespace.htm");
   GURL file_url = net::FilePathToFileURL(page_file_path);
   LoadPageFromURL(file_url);
   WebFrame* web_frame = FindSubFrameByURL(test_shell_->webView(), file_url);
   ASSERT_TRUE(web_frame != NULL);
   WebDocument doc = web_frame->document();
   WebNode lastNodeInBody = doc.body().lastChild();
   ASSERT_EQ(WebNode::ElementNode, lastNodeInBody.nodeType());
   WebString uri = webkit_glue::GetSubResourceLinkFromElement(
       lastNodeInBody.to<WebElement>());
   EXPECT_TRUE(uri.isNull());
 }
 
 }  // namespace