[Experimental] CSSSerializer Proof-of-concept

third_party/WebKit/Source/core/fetch/CSSStyleSheetResource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 
     This class provides all functionality needed for loading images, style sheets and html
     pages from the web. It has a memory cache for these objects.
 */
 
 #include "core/fetch/CSSStyleSheetResource.h"
 
 #include "core/css/StyleSheetContents.h"
+#include "core/css/serializer/CSSDeserializeStream.h"
+#include "core/css/serializer/CSSSerializeStream.h"
+#include "core/fetch/CachedMetadata.h"
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/ResourceClientWalker.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/fetch/StyleSheetResourceClient.h"
 #include "platform/SharedBuffer.h"
+#include "platform/TraceEvent.h"
 #include "platform/network/HTTPParsers.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
 ResourcePtr<CSSStyleSheetResource> CSSStyleSheetResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
 {
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
     request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextStyle);
     return toCSSStyleSheetResource(fetcher->requestResource(request, CSSStyleSheetResourceFactory()));
@@ skipping 98 matching lines @@
     // sniffing. Firefox does this by setting a "type hint" on the channel.
     // This implementation should be observationally equivalent.
     //
     // This code defaults to allowing the stylesheet for non-HTTP protocols so
     // folks can use standards mode for local HTML documents.
     if (mimeTypeCheck == MIMETypeCheck::Lax)
         return true;
     return mimeType().isEmpty() || equalIgnoringCase(mimeType(), "text/css") || equalIgnoringCase(mimeType(), "application/x-unknown-content-type");
 }
 
+PassRefPtrWillBeRawPtr<StyleSheetContents> CSSStyleSheetResource::deserializeStyleSheet(const CSSParserContext& context)
+{
+    TRACE_EVENT0("blink", "CSSStyleSheetResource::deserializeStyleSheet");
+    auto handler = cacheHandler();
+    if (!handler)
+        return nullptr;
+
+    unsigned cacheTag = 1; // wtf?
+    CachedMetadata* cachedMetadata = handler->cachedMetadata(cacheTag);
+    if (!cachedMetadata)
+        return nullptr;
+
+    CSDEBUG("found cachedMetadata: %zu\n", cachedMetadata->size());
+
+    RefPtrWillBeRawPtr<StyleSheetContents> sheet;
+ //   for (unsigned i = 0; i < 10000; ++ i)
+    {
+        sheet = StyleSheetContents::create(m_response.url(), context);
+        CSSDeserializeStream stream(cachedMetadata->data(), cachedMetadata->size());
+        sheet->deserialize(&stream);
+    }
+
+    return sheet.release();
+}
+
 PassRefPtrWillBeRawPtr<StyleSheetContents> CSSStyleSheetResource::restoreParsedStyleSheet(const CSSParserContext& context)
 {
     if (!m_parsedStyleSheetCache)
-        return nullptr;
+        return deserializeStyleSheet(context);
     if (m_parsedStyleSheetCache->hasFailedOrCanceledSubresources()) {
         m_parsedStyleSheetCache->removedFromMemoryCache();
         m_parsedStyleSheetCache.clear();
         return nullptr;
     }
 
     ASSERT(m_parsedStyleSheetCache->isCacheable());
     ASSERT(m_parsedStyleSheetCache->isInMemoryCache());
 
     // Contexts must be identical so we know we would get the same exact result if we parsed again.
     if (m_parsedStyleSheetCache->parserContext() != context)
         return nullptr;
 
     didAccessDecodedData();
 
     return m_parsedStyleSheetCache;
 }
 
 void CSSStyleSheetResource::saveParsedStyleSheet(PassRefPtrWillBeRawPtr<StyleSheetContents> sheet)
 {
     ASSERT(sheet && sheet->isCacheable());
 
+#if 0
     if (m_parsedStyleSheetCache)
         m_parsedStyleSheetCache->removedFromMemoryCache();
     m_parsedStyleSheetCache = sheet;
     m_parsedStyleSheetCache->addedToMemoryCache();
 
     setDecodedSize(m_parsedStyleSheetCache->estimatedSizeInBytes());
+#else
+    RefPtr<StyleSheetContents> parsedStyleSheet = sheet;
+
+    if (auto handler = cacheHandler()) {
+        TRACE_EVENT0("blink", "CSSStyleSheetResource::serializeStyleSheet");
+        CSSSerializeStream stream;
+        parsedStyleSheet->serialize(&stream);
+        CSDEBUG("serialized size: %zu\n", stream.data().size());
+
+        handler->clearCachedMetadata(CachedMetadataHandler::SendToPlatform);
+        unsigned cacheTag = 1; // wtf?
+        handler->setCachedMetadata(cacheTag, stream.data().data(), stream.data().size(), CachedMetadataHandler::SendToPlatform);
+
+        /*
+        FILE* fp = fopen("/usr/local/google/home/kouhei/cssserdestest/cssblob", "w");
+        fwrite(stream.data().data(), stream.data().size(), 1, fp);
+        fclose(fp);
+        */
+    } else {
+        CSDEBUG("no cacheHandler!\n");
+    }
+#endif
 }
 
 }