Add a few more edge cases to CSS serialization test.

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

 /*
  * Copyright (c) 2013, Opera Software ASA. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 61 matching lines @@
     Platform::current()->getURLLoaderMockFactory()->unregisterAllURLs();
     WebCache::clear();
   }
 
   void setBaseFolder(const char* folder) {
     m_folder = WebString::fromUTF8(folder);
   }
 
   void setRewriteURLFolder(const char* folder) { m_rewriteFolder = folder; }
 
+  void registerURL(const KURL& url, const char* file, const char* mimeType) {
+    registerMockedURLLoad(url, WebString::fromUTF8(file), m_folder,
+                          WebString::fromUTF8(mimeType));
+  }
+
   void registerURL(const char* url, const char* file, const char* mimeType) {
-    registerMockedURLLoad(KURL(m_baseUrl, url), WebString::fromUTF8(file),
-                          m_folder, WebString::fromUTF8(mimeType));
+    registerURL(KURL(m_baseUrl, url), file, mimeType);
   }
 
   void registerURL(const char* file, const char* mimeType) {
     registerURL(file, file, mimeType);
   }
 
   void registerErrorURL(const char* file, int statusCode) {
     WebURLError error;
     error.reason = 0xdead + statusCode;
     error.domain = "FrameSerializerTest";
 
     WebURLResponse response;
     response.setMIMEType("text/html");
     response.setHTTPStatusCode(statusCode);
 
     Platform::current()->getURLLoaderMockFactory()->registerErrorURL(
         KURL(m_baseUrl, file), response, error);
   }
 
   void registerRewriteURL(const char* fromURL, const char* toURL) {
     m_rewriteURLs.add(fromURL, toURL);
   }
 
+  void registerSkipURL(const char* url) {
+    m_skipURLs.append(KURL(m_baseUrl, url));
+  }
+
   void serialize(const char* url) {
     FrameTestHelpers::loadFrame(m_helper.webView()->mainFrame(),
                                 KURL(m_baseUrl, url).getString().utf8().data());
     FrameSerializer serializer(m_resources, *this);
     Frame* frame = m_helper.webView()->mainFrameImpl()->frame();
     for (; frame; frame = frame->tree().traverseNext()) {
       // This is safe, because tests do not do cross-site navigation
       // (and therefore don't have remote frames).
       serializer.serializeFrame(*toLocalFrame(frame));
     }
   }
 
   Vector<SerializedResource>& getResources() { return m_resources; }
 
-  const SerializedResource* getResource(const char* urlString,
-                                        const char* mimeType) {
-    const KURL url(m_baseUrl, urlString);
+  const SerializedResource* getResource(const KURL& url, const char* mimeType) {
     String mime(mimeType);
     for (size_t i = 0; i < m_resources.size(); ++i) {
       const SerializedResource& resource = m_resources[i];
       if (resource.url == url && !resource.data->isEmpty() &&
           (mime.isNull() || equalIgnoringASCIICase(resource.mimeType, mime)))
         return &resource;
     }
     return nullptr;
   }
 
+  const SerializedResource* getResource(const char* urlString,
+                                        const char* mimeType) {
+    const KURL url(m_baseUrl, urlString);
+    return getResource(url, mimeType);
+  }
+
   bool isSerialized(const char* url, const char* mimeType = 0) {
     return getResource(url, mimeType);
   }
 
   String getSerializedData(const char* url, const char* mimeType = 0) {
     const SerializedResource* resource = getResource(url, mimeType);
     if (resource)
       return String(resource->data->data(), resource->data->size());
     return String();
   }
@@ skipping 19 matching lines @@
       return false;
 
     StringBuilder uriBuilder;
     uriBuilder.append(m_rewriteFolder);
     uriBuilder.append('/');
     uriBuilder.append(m_rewriteURLs.get(completeURL));
     rewrittenLink = uriBuilder.toString();
     return true;
   }
 
+  bool shouldSkipResourceWithURL(const KURL& url) {
+    return m_skipURLs.contains(url);
+  }
+
   FrameTestHelpers::WebViewHelper m_helper;
   WebString m_folder;
   KURL m_baseUrl;
   Vector<SerializedResource> m_resources;
   HashMap<String, String> m_rewriteURLs;
+  Vector<String> m_skipURLs;
   String m_rewriteFolder;
 };
 
 TEST_F(FrameSerializerTest, HTMLElements) {
   setBaseFolder("frameserializer/elements/");
 
   registerURL("elements.html", "text/html");
   registerURL("style.css", "style.css", "text/css");
   registerURL("copyright.html", "empty.txt", "text/html");
   registerURL("script.js", "empty.txt", "text/javascript");
@@ skipping 140 matching lines @@
   registerURL("orange_background.png", "image.png", "image/png");
   registerURL("yellow_background.png", "image.png", "image/png");
   registerURL("green_background.png", "image.png", "image/png");
   registerURL("blue_background.png", "image.png", "image/png");
   registerURL("purple_background.png", "image.png", "image/png");
   registerURL("pink_background.png", "image.png", "image/png");
   registerURL("brown_background.png", "image.png", "image/png");
   registerURL("ul-dot.png", "image.png", "image/png");
   registerURL("ol-dot.png", "image.png", "image/png");
 
+  const KURL imageUrlFromDataUrl(toKURL("http://www.dataurl.com"),
+                                 "fuchsia_background.png");
+  registerURL(imageUrlFromDataUrl, "image.png", "image/png");
+
+  registerURL("included_in_another_frame.css", "text/css");
+  registerSkipURL("included_in_another_frame.css");
+
   serialize("css_test_page.html");
 
-  EXPECT_EQ(15U, getResources().size());
+  EXPECT_EQ(16U, getResources().size());
 
   EXPECT_FALSE(isSerialized("do_not_serialize.png", "image/png"));
+  EXPECT_FALSE(isSerialized("included_in_another_frame.css", "text/css"));
 
   EXPECT_TRUE(isSerialized("css_test_page.html", "text/html"));
   EXPECT_TRUE(isSerialized("link_styles.css", "text/css"));
   EXPECT_TRUE(isSerialized("encoding.css", "text/css"));
   EXPECT_TRUE(isSerialized("import_styles.css", "text/css"));
   EXPECT_TRUE(isSerialized("import_style_from_link.css", "text/css"));
   EXPECT_TRUE(isSerialized("red_background.png", "image/png"));
   EXPECT_TRUE(isSerialized("orange_background.png", "image/png"));
   EXPECT_TRUE(isSerialized("yellow_background.png", "image/png"));
   EXPECT_TRUE(isSerialized("green_background.png", "image/png"));
   EXPECT_TRUE(isSerialized("blue_background.png", "image/png"));
   EXPECT_TRUE(isSerialized("purple_background.png", "image/png"));
   EXPECT_TRUE(isSerialized("pink_background.png", "image/png"));
   EXPECT_TRUE(isSerialized("brown_background.png", "image/png"));
   EXPECT_TRUE(isSerialized("ul-dot.png", "image/png"));
   EXPECT_TRUE(isSerialized("ol-dot.png", "image/png"));
 
+  EXPECT_TRUE(getResource(imageUrlFromDataUrl, "image/png"));
+
   // Ensure encodings are specified.
   EXPECT_TRUE(
       getSerializedData("link_styles.css", "text/css").startsWith("@charset"));
   EXPECT_TRUE(getSerializedData("import_styles.css", "text/css")
                   .startsWith("@charset"));
   EXPECT_TRUE(getSerializedData("import_style_from_link.css", "text/css")
                   .startsWith("@charset"));
   EXPECT_TRUE(getSerializedData("encoding.css", "text/css")
                   .startsWith("@charset \"euc-kr\";"));
 
@@ skipping 155 matching lines @@
                 KURL(ParsedURLString, "http://foo.com?--")));
   EXPECT_EQ("saved from url=(0020)http://foo.com/#-%2D",
             FrameSerializer::markOfTheWebDeclaration(
                 KURL(ParsedURLString, "http://foo.com#--")));
   EXPECT_EQ("saved from url=(0026)http://foo.com/#bar-%2Dbaz",
             FrameSerializer::markOfTheWebDeclaration(
                 KURL(ParsedURLString, "http://foo.com#bar--baz")));
 }
 
 }  // namespace blink