Initial version of Blimp BlobCache.

blimp/engine/renderer/engine_image_serialization_processor.cc

 // 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 "blimp/engine/renderer/engine_image_serialization_processor.h"
 
 #include <stddef.h>
+#include <set>
+#include <string>
 #include <vector>
 
+#include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/sha1.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "blimp/common/blob_cache/sha1_util.h"
 #include "blimp/common/compositor/webp_decoder.h"
+#include "blimp/common/proto/blob_cache.pb.h"
 #include "content/public/renderer/render_frame.h"
 #include "third_party/libwebp/webp/encode.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkPixelSerializer.h"
 #include "third_party/skia/include/core/SkUnPreMultiply.h"
 
+namespace blimp {
 namespace {
+
+// TODO(nyquist): Add support for changing this from the client.
+static base::LazyInstance<std::set<std::string>> g_client_cache_contents =

[nyquist, 2016/04/16 00:25:30]

with base::LazyInstance<std::set<BlobID>> this fails with address() being
declared twice.
Same of course with base::LazyInstance<std::set<const std::string>>

Please advise.

[vmpstr, 2016/04/16 00:52:47]

What do ou mean address() being declared twice? Is it a compiler error? What is
it?

[nyquist, 2016/04/16 01:10:50]

Sent link to compile error on chat, but basically this and a few others related
to _Base::.

In file included from
../../blimp/engine/renderer/engine_image_serialization_processor.cc:5:
In file included from
../../blimp/engine/renderer/engine_image_serialization_processor.h:9:
In file included from ../../base/memory/scoped_ptr.h:12:
In file included from
../../build/linux/debian_wheezy_amd64-sysroot/usr/lib/gcc/x86_64-linux-gnu/4.6/../../../../include/c++/4.6/memory:65:
In file included from
../../build/linux/debian_wheezy_amd64-sysroot/usr/lib/gcc/x86_64-linux-gnu/4.6/../../../../include/c++/4.6/bits/allocator.h:48:
In file included from
../../build/linux/debian_wheezy_amd64-sysroot/usr/lib/gcc/x86_64-linux-gnu/4.6/../../../../include/c++/4.6/x86_64-linux-gnu/bits/c++allocator.h:34:
../../build/linux/debian_wheezy_amd64-sysroot/usr/lib/gcc/x86_64-linux-gnu/4.6/../../../../include/c++/4.6/ext/new_allocator.h:82:7:
error: multiple overloads of 'address' instantiate to the same signature
'const_pointer (const_reference) const' (aka 'const std::basic_string<char, 
std::char_traits<char>, std::allocator<char> > *(const std::basic_string<char,
std::char_traits<char>, std::allocator<char> > &) const')
      address(const_reference __x) const { return std::__addressof(__x); }
      ^
../../build/linux/debian_wheezy_amd64-sysroot/usr/lib/gcc/x86_64-linux-gnu/4.6/../../../../include/c++/4.6/bits/allocator.h:92:29:
note: in instantiation of template class '__gnu_cxx::new_allocator<const
std::basic_string<char, std::char_traits<char>, std::allocator<char> > >' requ
ested here
    class allocator: public __glibcxx_base_allocator<_Tp>
                            ^
../../build/linux/debian_wheezy_amd64-sysroot/usr/lib/gcc/x86_64-linux-gnu/4.6/../../../../include/c++/4.6/x86_64-linux-gnu/bits/c++allocator.h:35:35:
note: expanded from macro '__glibcxx_base_allocator'
#define __glibcxx_base_allocator  __gnu_cxx::new_allocator
                                  ^
../../build/linux/debian_wheezy_amd64-sysroot/usr/lib/gcc/x86_64-linux-gnu/4.6/../../../../include/c++/4.6/bits/stl_set.h:92:24:
note: in instantiation of template class 'std::allocator<const
std::basic_string<char, std::char_traits<char>, std::allocator<char> > >'
requested here
      typedef typename _Alloc::value_type                   _Alloc_value_type;
                       ^
../../build/linux/debian_wheezy_amd64-sysroot/usr/lib/gcc/x86_64-linux-gnu/4.6/../../../../include/c++/4.6/debug/set.h:45:14:
note: in instantiation of template class 'std::__cxx1998::set<const
std::basic_string<char, std::char_traits<char>, std::allocator<char> >,
std::less<const 
std::basic_string<char, std::char_traits<char>, std::allocator<char> > >,
std::allocator<const std::basic_string<char, std::char_traits<char>,
std::allocator<char> > > >' requested here
    : public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>,
             ^
../../build/linux/debian_wheezy_amd64-sysroot/usr/lib/gcc/x86_64-linux-gnu/4.6/../../../../include/c++/4.6/x86_64-linux-gnu/bits/c++config.h:266:25:
note: expanded from macro '_GLIBCXX_STD_C'
# define _GLIBCXX_STD_C __cxx1998
                        ^
../../blimp/engine/renderer/engine_image_serialization_processor.cc:30:29: note:
in instantiation of template class 'std::__debug::set<const
std::basic_string<char, std::char_traits<char>, std::allocator<char> >,
std::less<const std::basic_string<char, std::char_traits<char>, std::
allocator<char> > >, std::allocator<const std::basic_string<char,
std::char_traits<char>, std::allocator<char> > > >' requested here
std::set<const std::string> g_client_cache_contents;
                            ^
../../build/linux/debian_wheezy_amd64-sysroot/usr/lib/gcc/x86_64-linux-gnu/4.6/../../../../include/c++/4.6/ext/new_allocator.h:79:7:
note: previous declaration is here
      address(reference __x) const { return std::__addressof(__x); }

+    LAZY_INSTANCE_INITIALIZER;
+
+SkData* BlobCacheImageMetadataProtoAsSkData(
+    const BlobCacheImageMetadata& proto) {
+  int signed_size = proto.ByteSize();
+  size_t unsigned_size = base::checked_cast<size_t>(signed_size);
+  std::vector<uint8_t> serialized(unsigned_size);
+  proto.SerializeToArray(serialized.data(), signed_size);
+  return SkData::NewWithCopy(serialized.data(), serialized.size());
+}
+
 // TODO(nyquist): Make sure encoder does not serialize images more than once.
 // See crbug.com/548434.
 class WebPImageEncoder : public SkPixelSerializer {
  public:
   WebPImageEncoder() {}
   ~WebPImageEncoder() override{};
 
   bool onUseEncodedData(const void* data, size_t len) override {
-    const unsigned char* cast_data = static_cast<const unsigned char*>(data);
-    if (len < 14)
-      return false;
-    return !memcmp(cast_data, "RIFF", 4) && !memcmp(cast_data + 8, "WEBPVP", 6);
+    // Always encode even WebP data, to enable caching.
+    return false;
   }
 
   SkData* onEncode(const SkPixmap& pixmap) override {
     // Initialize an empty WebPConfig.
     WebPConfig config;
     if (!WebPConfigInit(&config))
       return nullptr;
 
     // Initialize an empty WebPPicture.
     WebPPicture picture;
     if (!WebPPictureInit(&picture))
       return nullptr;
 
     // Ensure width and height are valid dimensions.
     if (!pixmap.width() || pixmap.width() > WEBP_MAX_DIMENSION)
       return nullptr;
     picture.width = pixmap.width();
     if (!pixmap.height() || pixmap.height() > WEBP_MAX_DIMENSION)
       return nullptr;
     picture.height = pixmap.height();
 
+    BlobId blob_id = CalculateBlobId(pixmap.addr(), pixmap.getSafeSize());
+    std::string blob_id_hex = FormatBlobId(blob_id);
+
+    // Create proto with all requires information.
+    BlobCacheImageMetadata proto;
+    proto.set_id(blob_id);
+    proto.set_width(pixmap.width());
+    proto.set_height(pixmap.height());
+
+    if (g_client_cache_contents.Get().find(blob_id) !=
+        g_client_cache_contents.Get().end()) {
+      // Found image in client cache, so skip sending decoded payload.
+      SkData* sk_data = BlobCacheImageMetadataProtoAsSkData(proto);
+      DVLOG(2) << "Sending cached: " << blob_id_hex
+               << " size = " << sk_data->size();
+      return sk_data;
+    }
+
     DVLOG(2) << "Encoding image color_type=" << pixmap.colorType()
              << ", alpha_type=" << pixmap.alphaType() << " " << pixmap.width()
              << "x" << pixmap.height();
 
     // Import picture from raw pixels.
     auto pixel_chars = static_cast<const unsigned char*>(pixmap.addr());
     if (!PlatformPictureImport(pixel_chars, &picture, pixmap.alphaType()))
       return nullptr;
 
     // Create a buffer for where to store the output data.
@@ skipping 13 matching lines @@
     // Encode the picture using the given configuration.
     bool success = WebPEncode(&config, &picture);
 
     // Release the memory allocated by WebPPictureImport*(). This does not free
     // the memory used by the picture object itself.
     WebPPictureFree(&picture);
 
     if (!success)
       return nullptr;
 
-    // Copy WebP data into SkData. |data| is allocated only on the stack, so
-    // it is automatically deleted after this.
-    return SkData::NewWithCopy(&data.front(), data.size());
+    // Did not find item in cache, so add it to client cache representation
+    // and send full item.
+    g_client_cache_contents.Get().insert(blob_id);
+    proto.set_payload(&data.front(), data.size());
+
+    // Copy proto into SkData.
+    SkData* sk_data = BlobCacheImageMetadataProtoAsSkData(proto);
+    DVLOG(2) << "Sending image: " << blob_id_hex
+             << " size = " << sk_data->size();
+    return sk_data;
   }
 
  private:
   // WebPWriterFunction implementation.
   static int WriteOutput(const uint8_t* data,
                          size_t size,
                          const WebPPicture* const picture) {
     std::vector<unsigned char>* dest =
         static_cast<std::vector<unsigned char>*>(picture->custom_ptr);
     dest->insert(dest->end(), data, data + size);
@@ skipping 43 matching lines @@
     }
 
     if (SK_B32_SHIFT)  // Android
       return WebPPictureImportRGBA(picture, pixels, row_stride);
     return WebPPictureImportBGRA(picture, pixels, row_stride);
   }
 };
 
 }  // namespace
 
-namespace blimp {
 namespace engine {
 
 EngineImageSerializationProcessor::EngineImageSerializationProcessor(
     mojom::BlobChannelPtr blob_channel)
     : blob_channel_(std::move(blob_channel)) {
   DCHECK(blob_channel_);
 
   pixel_serializer_.reset(new WebPImageEncoder);
 
   // Dummy BlobChannel command.
   // TODO(nyquist): Remove this after integrating BlobChannel.
   blob_channel_->Push("foo");
 }
 
 EngineImageSerializationProcessor::~EngineImageSerializationProcessor() {}
 
 SkPixelSerializer* EngineImageSerializationProcessor::GetPixelSerializer() {
   return pixel_serializer_.get();
 }
 
 SkPicture::InstallPixelRefProc
 EngineImageSerializationProcessor::GetPixelDeserializer() {
   return nullptr;
 }
 
 }  // namespace engine
 }  // namespace blimp