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 <unordered_map>
 #include <utility>
 
 #include "blimp/common/blob_cache/id_util.h"
 #include "content/public/renderer/render_thread.h"
 #include "services/shell/public/cpp/interface_provider.h"
 
 namespace blimp {
 namespace engine {
 namespace {
 
@@ skipping 37 matching lines @@
   mojo::ScopedSharedBufferHandle remote_handle =
       local_handle_->Clone(mojo::SharedBufferHandle::AccessMode::READ_ONLY);
   CHECK(remote_handle.is_valid())
       << "Mojo error when creating read-only buffer handle.";
   return remote_handle;
 }
 
 }  // namespace
 
 BlobChannelSenderProxy::BlobChannelSenderProxy()
-    : BlobChannelSenderProxy(GetConnectedBlobChannel()) {}
+    : blob_channel_(GetConnectedBlobChannel()), weak_factory_(this) {
+  blob_channel_->GetCachedBlobIds(
+      base::Bind(&BlobChannelSenderProxy::OnGetCacheStateComplete,
+                 weak_factory_.GetWeakPtr()));
+}
 
 BlobChannelSenderProxy::~BlobChannelSenderProxy() {}
 
 BlobChannelSenderProxy::BlobChannelSenderProxy(
     mojom::BlobChannelPtr blob_channel)
-    : blob_channel_(std::move(blob_channel)) {}
+    : blob_channel_(std::move(blob_channel)), weak_factory_(this) {}
 
 // static
 std::unique_ptr<BlobChannelSenderProxy> BlobChannelSenderProxy::CreateForTest(
     mojom::BlobChannelPtr blob_channel) {
   return base::WrapUnique(new BlobChannelSenderProxy(std::move(blob_channel)));
 }
 
 bool BlobChannelSenderProxy::IsInEngineCache(const std::string& id) const {
   return replication_state_.find(id) != replication_state_.end();
 }
@@ skipping 22 matching lines @@
                                << BlobIdToString(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::CacheStateEntry>
+BlobChannelSenderProxy::GetCachedBlobIds() const {
+  NOTREACHED();
+  return std::vector<BlobChannelSender::CacheStateEntry>();
+}
+
+void BlobChannelSenderProxy::OnGetCacheStateComplete(
+    const std::unordered_map<std::string, bool>& 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.first] = next_item.second;
+  }
+}
+
 }  // namespace engine
 }  // namespace blimp