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 {
+
+// TODO(nyquist): Add support for changing this from the client.
+static base::LazyInstance<std::set<std::vector<unsigned char>>>
+    g_client_cache_contents = LAZY_INSTANCE_INITIALIZER;
+
+SkData* BlobCacheImageMetadataProtoAsSkData(
+    const blimp::BlobCacheImageMetadata& proto) {
+  int signed_size = proto.ByteSize();
+  size_t unsigned_size = base::checked_cast<size_t>(signed_size);

[vmpstr, 2016/04/15 18:18:54]

This is super safe and all, but do you need this? Can you comment on when you
think proto.ByteSize() would not be representable by size_t?

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

It returns an int, which could be negative, so we don't want that. After
security review of code related to passing protos around, the security team
wanted us to do this for protos.

+  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();
 
+    // Each pixel is using 4 bytes (RGBA/BGRA), so hash over the whole input.

[Kevin M, 2016/04/15 17:28:51]

Is there something we can check to validate the pixel format assertion? I think 
the consequence of guessing wrongly is that we compute a bogus size value that
could potentially overrun the pixmap.addr() buffer.

[vmpstr, 2016/04/15 18:18:54]

SkPixmap has a bunch of functions to tell you the size (I recommend
SkPixmap::getSafeSize).

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

Doh... I thought they looked like row size :-/

they all return the same value as my ugly hack in the normal case, so I went
with getSafeSize.

Done.

+    size_t pixel_size = picture.width * picture.height * 4;
+    std::vector<unsigned char> sha1_bytes =
+        blimp::ToSHA1HashBytes(pixmap.addr(), pixel_size);
+    std::string sha1 = blimp::FormatSHA1Hash(sha1_bytes.data());
+
+    // Create proto with all requires information.
+    std::unique_ptr<blimp::BlobCacheImageMetadata> proto(

[vmpstr, 2016/04/15 18:18:54]

Create this on the stack?

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

Done.

+        new blimp::BlobCacheImageMetadata);
+    proto->set_id(sha1_bytes.data(), sha1_bytes.size());
+    proto->set_width(pixmap.width());
+    proto->set_height(pixmap.height());
+
+    if (g_client_cache_contents.Get().find(sha1_bytes) !=
+        g_client_cache_contents.Get().end()) {
+      // Found image in client cache, so skip sending decoded payload.
+      SkData* sk_data = BlobCacheImageMetadataProtoAsSkData(*proto.get());

[vmpstr, 2016/04/15 18:18:54]

If you create proto on the stack, then *proto.get() becomes just proto. 

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

Done.

+      DVLOG(2) << "Sending cached: " << sha1 << " 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(sha1_bytes);
+    proto->set_payload(&data.front(), data.size());
+
+    // Copy proto into SkData.
+    SkData* sk_data = BlobCacheImageMetadataProtoAsSkData(*proto.get());
+    DVLOG(2) << "Sending image: " << sha1 << " 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 71 matching lines @@
   return pixel_serializer_.get();
 }
 
 SkPicture::InstallPixelRefProc
 EngineImageSerializationProcessor::GetPixelDeserializer() {
   return nullptr;
 }
 
 }  // namespace engine
 }  // namespace blimp