Add Mojo IPC for seeding new Renderer with Browser's cached blob state.

blimp/engine/renderer/blob_channel_sender_proxy.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/blob_channel_sender_proxy.h"
 
 #include "content/public/common/service_registry.h"
 #include "content/public/renderer/render_thread.h"
 
 namespace blimp {
 namespace engine {
 namespace {
 
 mojom::BlobChannelPtr GetConnectedBlobChannel() {
   mojom::BlobChannelPtr blob_channel_ptr;
   content::RenderThread::Get()->GetServiceRegistry()->ConnectToRemoteService(
       mojo::GetProxy(&blob_channel_ptr));
   CHECK(blob_channel_ptr) << "Could not connect to BlobChannel Mojo service.";
   return blob_channel_ptr;
 }
 
 }  // namespace
 
 BlobChannelSenderProxy::BlobChannelSenderProxy()
-    : blob_channel_(GetConnectedBlobChannel()) {}
+    : blob_channel_(GetConnectedBlobChannel()), weak_factory_(this) {
+  // Asynchronously request the set of cache keys from the browser process.
+  // Knowledge of the browser's cache allows the renderer to avoid re-encoding
+  // and re-transferring image assets that are already tracked by the
+  // browser-side cache.
+  //
+  // If |this| is used in the brief time before the response arrives,
+  // the object will continue to work, but false negatives will be returned
+  // for IsInEngineCache() and IsInClientCache().

[Wez, 2016/06/21 00:33:33]

This is a property the caller needs to be aware of, surely, so not really
something to document in the implementation?

[Kevin M, 2016/06/21 21:23:52]

Done, moved to header file.

+  //
+  // TODO(kmarshall): Switch to observer push model (vs. the current pull model)
+  // once cache invalidations are introduced.
+  blob_channel_->GetCacheState(base::Bind(
+      &BlobChannelSenderProxy::GotCacheState, weak_factory_.GetWeakPtr()));
+}
 
 BlobChannelSenderProxy::~BlobChannelSenderProxy() {}
 
 bool BlobChannelSenderProxy::IsInEngineCache(const std::string& id) const {
   return replication_state_.find(id) != replication_state_.end();
 }
 
 bool BlobChannelSenderProxy::IsInClientCache(const std::string& id) const {
   return replication_state_.find(id)->second;
 }
 
 void BlobChannelSenderProxy::PutBlob(const BlobId& id, BlobDataPtr data) {
   DCHECK(!IsInEngineCache(id));
 
   replication_state_[id] = false;
   blob_channel_->PutBlob(id, data->data);
 }
 
 void BlobChannelSenderProxy::DeliverBlob(const std::string& id) {
   DCHECK(!IsInClientCache(id));
 
   // We assume that the client will have the blob if we push it.
   // TODO(kmarshall): Revisit this assumption when asynchronous blob transport
   // is supported.
   replication_state_[id] = true;
 
   blob_channel_->DeliverBlob(id);
 }
 
+std::vector<BlobChannelSender::CacheState>
+BlobChannelSenderProxy::GetCacheState() const {
+  NOTREACHED();
+  return std::vector<BlobChannelSender::CacheState>();

[Wez, 2016/06/21 00:33:33]

Why not-implemented? Why not return a copy of replication_state_'s keys?

[Kevin M, 2016/06/21 21:23:52]

Done.

[Wez, 2016/06/22 19:54:23]

(Or is it the case that no-one will ever call this..?)

[Kevin M, 2016/06/22 23:52:52]

Yes, that is the case. <_<

+}
+
+void BlobChannelSenderProxy::GotCacheState(
+    mojo::Array<mojom::CacheStateEntryPtr> cache_state) {
+  VLOG(1) << "Received cache state from browser (" << cache_state.size()
+          << " items)";
+  replication_state_.clear();
+  for (const auto& next_item : cache_state) {
+    replication_state_[next_item->id] = next_item->is_replicated;
+  }
+}
+
 }  // namespace engine
 }  // namespace blimp