DO NOT COMMIT: Actual compression in CompressibleString

third_party/WebKit/Source/platform/text/CompressibleString.cpp

 // Copyright 2016 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 "platform/text/CompressibleString.h"
 
 #include "public/platform/Platform.h"
+#include "third_party/zlib/google/compression_utils.h"
 #include "wtf/Assertions.h"
 #include "wtf/WTFThreadData.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 class CompressibleStringTable {
     WTF_MAKE_NONCOPYABLE(CompressibleStringTable);
 public:
     static CompressibleStringTable* create(WTFThreadData& data)
@@ skipping 52 matching lines @@
 
 static const unsigned CompressibleStringImplSizeThrehold = 100000;
 
 void CompressibleStringImpl::compressAll()
 {
     compressibleStringTable().compressAll();
 }
 
 CompressibleStringImpl::CompressibleStringImpl(PassRefPtr<StringImpl> impl)
     : m_string(impl)
-    , m_isCompressed(false)
+    , m_originalLength(m_string.length())
+    , m_compressedData(nullptr)
+    , m_compressedDataSize(0)
 {
     if (originalContentSizeInBytes() > CompressibleStringImplSizeThrehold)
         compressibleStringTable().add(this);
 }
 
 CompressibleStringImpl::~CompressibleStringImpl()
 {
     if (originalContentSizeInBytes() > CompressibleStringImplSizeThrehold)
         compressibleStringTable().remove(this);
 }
 
 enum CompressibleStringCountType {
     StringWasCompressedInBackgroundTab,
     StringWasDecompressed,
     CompressibleStringCountTypeMax = StringWasDecompressed,
 };
 
 static void recordCompressibleStringCount(CompressibleStringCountType type)
 {
     Platform::current()->histogramEnumeration("Memory.CompressibleStringCount", type, CompressibleStringCountTypeMax + 1);
 }
 
-// compressString does nothing but collect UMA so far.
-// TODO(hajimehoshi): Implement this.
 void CompressibleStringImpl::compressString()
 {
     recordCompressibleStringCount(StringWasCompressedInBackgroundTab);
     ASSERT(!isCompressed());
-    m_isCompressed = true;
+    ASSERT(!m_compressedData);
+    ASSERT(!m_compressedDataSize);
+
+    // TODO(hajimehoshi): Now components offers funcitons accepting only
+    // std::strings. This is not efficient. We should offer char* version.
+    std::string in, out;
+    if (m_string.is8Bit()) {
+        in = std::string(reinterpret_cast<const char*>(m_string.characters8()), originalContentSizeInBytes());
+        m_string = emptyString();
+    } else {
+        in = std::string(reinterpret_cast<const char*>(m_string.characters16()),  originalContentSizeInBytes());
+        m_string = emptyString16Bit();
+    }
+    compression::GzipCompress(in, &out);
+
+    m_compressedData = WTF::Partitions::fastMalloc(out.size(), "CompressibleString");
+    memcpy(m_compressedData, out.c_str(), out.size());
+    m_compressedDataSize = out.size();
 }
 
-// decompressString does nothing but collect UMA so far.
-// TODO(hajimehoshi): Implement this.
 void CompressibleStringImpl::decompressString()
 {
     // TODO(hajimehoshi): We wanted to tell whether decompressing in a
     // background tab or a foreground tab, but this was impossible. For example,
     // one renderer process of a new tab page is used for multiple tabs.
     // Another example is that reloading a page will re-use the process with a
     // new Page object and updating a static variable along with reloading will
     // be complex. See also crbug/581266. We will revisit when the situation
     // changes.
     recordCompressibleStringCount(StringWasDecompressed);
     ASSERT(isCompressed());
-    m_isCompressed = false;
+    ASSERT(m_compressedData);
+    ASSERT(m_compressedDataSize);
+
+    std::string in(static_cast<const char*>(m_compressedData), m_compressedDataSize);
+    std::string out;
+    compression::GzipUncompress(in, &out);
+
+    if (is8Bit()) {
+        LChar* data = nullptr;
+        m_string = StringImpl::createUninitialized(out.size() / sizeof(LChar), data);
+        memcpy(data, out.c_str(), out.size());
+    } else {
+        UChar* data = nullptr;
+        m_string = StringImpl::createUninitialized(out.size() / sizeof(UChar), data);
+        memcpy(data, out.c_str(), out.size());
+    }
+
+    WTF::Partitions::fastFree(m_compressedData);
+    m_compressedData = nullptr;
+    m_compressedDataSize = 0;
+    ASSERT(m_originalLength == m_string.length());
 }
 
 } // namespace blink