Blimp: Add BlobChannelReceiver and bindings interface.

blimp/net/blob_channel/blob_channel_receiver.h

+// 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.
+
+#ifndef BLIMP_NET_BLOB_CHANNEL_BLOB_CHANNEL_RECEIVER_H_
+#define BLIMP_NET_BLOB_CHANNEL_BLOB_CHANNEL_RECEIVER_H_
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/synchronization/lock.h"
+#include "blimp/common/blob_cache/blob_cache.h"
+#include "blimp/net/blimp_message_processor.h"
+#include "blimp/net/blimp_net_export.h"
+
+namespace blimp {
+
+class BlobCache;
+
+// Receives blobs from a remote sender.
+class BLIMP_NET_EXPORT BlobChannelReceiver {
+ public:
+  class Delegate {
+   public:
+    Delegate();
+    virtual ~Delegate();
+
+   protected:
+    // Forwards incoming blob data to |receiver_|.
+    void OnBlobReceived(const BlobId& id, BlobDataPtr data);
+
+   private:
+    friend class BlobChannelReceiver;
+
+    // Sets the Receiver object which will take incoming blobs.
+    void SetReceiver(BlobChannelReceiver* receiver);
+
+    BlobChannelReceiver* receiver_ = nullptr;
+
+    DISALLOW_COPY_AND_ASSIGN(Delegate);
+  };
+
+  BlobChannelReceiver(std::unique_ptr<BlobCache> cache,
+                      std::unique_ptr<Delegate> delegate);
+  ~BlobChannelReceiver();
+
+  // Gets a blob from the BlobChannel.
+  // Returns nullptr if the blob is not available in the channel.
+  BlobDataPtr Get(const BlobId& id);
+
+ private:
+  friend class Delegate;
+
+  // Called by Delegate::OnBlobReceived() when a blob arrives over the channel.
+  void OnBlobReceived(const BlobId& id, BlobDataPtr data);
+
+  std::unique_ptr<BlobCache> cache_;
+  std::unique_ptr<Delegate> delegate_;
+
+  // Guards against concurrent access to |cache_| and |active_read_callbacks_|.

[Wez, 2016/04/21 00:55:02]

There is no |active_read_callbacks_| here?

Concurrent access by whom?  Are you suggesting that Get() is called from a
different thread (or threads?) to OnBlobReceived()?

If that's somehow a valid usage of this class then comment on the thread-safety
properties in a class comment.

[Kevin M, 2016/04/21 21:24:08]

Removed obsolete comment.

Yeah, this needs to allow concurrent access from a number of render threads.

[Wez, 2016/04/21 22:52:50]

If it's a resource shared across multiple threads then should it be ref-counted?
Does it need to be deleted on a specific thread, e.g. the one on which it was
created?

[Kevin M, 2016/04/22 00:21:24]

We don't need to. We can safely assume that the raster threads will be torn down
before the AtExitManager is invoked (blimp_main =owns=> client session =>
compositor feature => compositor manager => threads).
Not currently, but I don't know about the future - that probably depends on the
requirements of the BlobCache impl?

+  base::Lock lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlobChannelReceiver);
+};
+
+}  // namespace blimp
+
+#endif  // BLIMP_NET_BLOB_CHANNEL_BLOB_CHANNEL_RECEIVER_H_