Split WebFrameSerializerSanitizationTest into its own file.

third_party/WebKit/Source/web/tests/WebFrameSerializerSanitizationTest.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 21 matching lines @@
 
 #include "core/exported/WebViewBase.h"
 #include "platform/mhtml/MHTMLArchive.h"
 #include "platform/mhtml/MHTMLParser.h"
 #include "platform/testing/HistogramTester.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/wtf/text/StringBuilder.h"
 #include "public/platform/Platform.h"
-#include "public/platform/WebCString.h"
-#include "public/platform/WebCache.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLLoaderMockFactory.h"
-#include "public/web/WebFrameSerializerClient.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/tests/FrameTestHelpers.h"
 
 namespace blink {
 
 namespace {
-class SimpleWebFrameSerializerClient final : public WebFrameSerializerClient {
- public:
-  String ToString() { return builder_.ToString(); }
-
- private:
-  void DidSerializeDataForFrame(const WebCString& data,
-                                FrameSerializationStatus) final {
-    builder_.Append(data.Data(), data.length());
-  }
-
-  StringBuilder builder_;
-};
 
 class SimpleMHTMLPartsGenerationDelegate
     : public WebFrameSerializer::MHTMLPartsGenerationDelegate {
  public:
   SimpleMHTMLPartsGenerationDelegate() : remove_popup_overlay_(false) {}
 
   void SetRemovePopupOverlay(bool remove_popup_overlay) {
     remove_popup_overlay_ = remove_popup_overlay;
   }
 
@@ skipping 21 matching lines @@
     if (pos == WTF::kNotFound)
       break;
     matches++;
     start = pos + size;
   }
   return matches;
 }
 
 }  // namespace
 
-class WebFrameSerializerTest : public ::testing::Test {
+class WebFrameSerializerSanitizationTest : public ::testing::Test {
  protected:
-  WebFrameSerializerTest() { helper_.Initialize(); }
+  WebFrameSerializerSanitizationTest() { helper_.Initialize(); }
 
-  ~WebFrameSerializerTest() override {
+  ~WebFrameSerializerSanitizationTest() override {
     Platform::Current()
         ->GetURLLoaderMockFactory()
         ->UnregisterAllURLsAndClearMemoryCache();
   }
 
-  void RegisterMockedImageURLLoad(const String& url) {
-    // Image resources need to be mocked, but irrelevant here what image they
-    // map to.
-    RegisterMockedFileURLLoad(URLTestHelpers::ToKURL(url.Utf8().data()),
-                              "frameserialization/awesome.png");
-  }
-  void RegisterMockedFileURLLoad(const KURL& url,
-                                 const String& file_path,
-                                 const String& mime_type = "image/png") {
-    URLTestHelpers::RegisterMockedURLLoad(
-        url, testing::WebTestDataPath(file_path.Utf8().data()), mime_type);
-  }
-
-  class SingleLinkRewritingDelegate
-      : public WebFrameSerializer::LinkRewritingDelegate {
-   public:
-    SingleLinkRewritingDelegate(const WebURL& url, const WebString& local_path)
-        : url_(url), local_path_(local_path) {}
-
-    bool RewriteFrameSource(WebFrame* frame,
-                            WebString* rewritten_link) override {
-      return false;
-    }
-
-    bool RewriteLink(const WebURL& url, WebString* rewritten_link) override {
-      if (url != url_)
-        return false;
-
-      *rewritten_link = local_path_;
-      return true;
-    }
-
-   private:
-    const WebURL url_;
-    const WebString local_path_;
-  };
-
-  String SerializeFile(const String& url, const String& file_name) {
-    KURL parsed_url(kParsedURLString, url);
-    String file_path("frameserialization/" + file_name);
-    RegisterMockedFileURLLoad(parsed_url, file_path, "text/html");
-    FrameTestHelpers::LoadFrame(MainFrameImpl(), url.Utf8().data());
-    SingleLinkRewritingDelegate delegate(parsed_url, WebString("local"));
-    SimpleWebFrameSerializerClient serializer_client;
-    WebFrameSerializer::Serialize(MainFrameImpl(), &serializer_client,
-                                  &delegate);
-    return serializer_client.ToString();
-  }
-
-  WebViewBase* WebView() { return helper_.WebView(); }
-
-  WebLocalFrameImpl* MainFrameImpl() {
-    return helper_.WebView()->MainFrameImpl();
-  }
-
- private:
-  FrameTestHelpers::WebViewHelper helper_;
-};
-
-TEST_F(WebFrameSerializerTest, URLAttributeValues) {
-  RegisterMockedImageURLLoad("javascript:\"");
-
-  const char* expected_html =
-      "\n<!-- saved from url=(0020)http://www.test.com/ -->\n"
-      "<html><head><meta http-equiv=\"Content-Type\" content=\"text/html; "
-      "charset=UTF-8\">\n"
-      "</head><body><img src=\"javascript:&quot;\">\n"
-      "<a href=\"http://www.test.com/local#&quot;\">local</a>\n"
-      "<a "
-      "href=\"http://www.example.com/#&quot;&gt;&lt;script&gt;alert(0)&lt;/"
-      "script&gt;\">external</a>\n"
-      "</body></html>";
-  String actual_html =
-      SerializeFile("http://www.test.com", "url_attribute_values.html");
-  EXPECT_EQ(expected_html, actual_html);
-}
-
-TEST_F(WebFrameSerializerTest, EncodingAndNormalization) {
-  const char* expected_html =
-      "<!DOCTYPE html>\n"
-      "<!-- saved from url=(0020)http://www.test.com/ -->\n"
-      "<html><head><meta http-equiv=\"Content-Type\" content=\"text/html; "
-      "charset=EUC-KR\">\n"
-      "<title>Ensure NFC normalization is not performed by frame "
-      "serializer</title>\n"
-      "</head><body>\n"
-      "\xe4\xc5\xd1\xe2\n"
-      "\n</body></html>";
-  String actual_html =
-      SerializeFile("http://www.test.com", "encoding_normalization.html");
-  EXPECT_EQ(expected_html, actual_html);
-}
-
-TEST_F(WebFrameSerializerTest, FromUrlWithMinusMinus) {
-  String actual_html =
-      SerializeFile("http://www.test.com?--x--", "text_only_page.html");
-  EXPECT_EQ("<!-- saved from url=(0030)http://www.test.com/?-%2Dx-%2D -->",
-            actual_html.Substring(1, 60));
-}
-
-class WebFrameSerializerSanitizationTest : public WebFrameSerializerTest {
- protected:
-  WebFrameSerializerSanitizationTest() {}
-
-  ~WebFrameSerializerSanitizationTest() override {}
-
   String GenerateMHTMLFromHtml(const String& url, const String& file_name) {
     return GenerateMHTML(url, file_name, "text/html", false);
   }
 
   String GenerateMHTMLPartsFromPng(const String& url, const String& file_name) {
     return GenerateMHTML(url, file_name, "image/png", true);
   }
 
   String GenerateMHTML(const String& url,
                        const String& file_name,
@@ skipping 33 matching lines @@
       EXPECT_FALSE(parser.ParseArchive().IsEmpty())
           << "Generated MHTML is not well formed";
     }
     return mhtml_string;
   }
 
   void SetRemovePopupOverlay(bool remove_popup_overlay) {
     mhtml_delegate_.SetRemovePopupOverlay(remove_popup_overlay);
   }
 
- protected:
+  void RegisterMockedFileURLLoad(const KURL& url,
+                                 const String& file_path,
+                                 const String& mime_type = "image/png") {
+    URLTestHelpers::RegisterMockedURLLoad(
+        url, testing::WebTestDataPath(file_path.Utf8().data()), mime_type);
+  }
+
+  WebViewBase* WebView() { return helper_.WebView(); }
+
+  WebLocalFrameImpl* MainFrameImpl() {
+    return helper_.WebView()->MainFrameImpl();
+  }
+
   HistogramTester histogram_tester_;
 
  private:
+  FrameTestHelpers::WebViewHelper helper_;
   SimpleMHTMLPartsGenerationDelegate mhtml_delegate_;
 };
 
 TEST_F(WebFrameSerializerSanitizationTest, RemoveInlineScriptInAttributes) {
   String mhtml =
       GenerateMHTMLFromHtml("http://www.test.com", "script_in_attributes.html");
 
   // These scripting attributes should be removed.
   EXPECT_EQ(WTF::kNotFound, mhtml.Find("onload="));
   EXPECT_EQ(WTF::kNotFound, mhtml.Find("ONLOAD="));
@@ skipping 157 matching lines @@
             mhtml.Find("<meta http-equiv=3D\"Content-Security-Policy"));
   EXPECT_NE(WTF::kNotFound, mhtml.Find("<meta name=3D\"description"));
   EXPECT_NE(WTF::kNotFound, mhtml.Find("<meta http-equiv=3D\"refresh"));
 
   // If an element is removed, its children should also be skipped.
   EXPECT_EQ(WTF::kNotFound, mhtml.Find("<select"));
   EXPECT_EQ(WTF::kNotFound, mhtml.Find("<option"));
 }
 
 }  // namespace blink