content/renderer/media/android/stream_texture_factory.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_RENDERER_MEDIA_ANDROID_STREAM_TEXTURE_FACTORY_H_
   6 #define CONTENT_RENDERER_MEDIA_ANDROID_STREAM_TEXTURE_FACTORY_H_
   7
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/single_thread_task_runner.h"
  11 #include "cc/layers/video_frame_provider.h"
  12 #include "gpu/command_buffer/common/mailbox.h"
  13 #include "ui/gfx/geometry/size.h"
  14
  15 namespace gpu {
  16 namespace gles2 {
  17 class GLES2Interface;
  18 }  // namespace gles2
  19 }  // namespace gpu
  20
  21 namespace content {
  22
  23 // The proxy class for the gpu thread to notify the compositor thread
  24 // when a new video frame is available.
  25 class StreamTextureProxy {
  26  public:
  27   virtual ~StreamTextureProxy() {}
  28
  29   // Initialize and bind to the loop, which becomes the thread that
  30   // a connected client will receive callbacks on. This can be called
  31   // on any thread, but must be called with the same loop every time.
  32   virtual void BindToLoop(int32 stream_id,
  33                           cc::VideoFrameProvider::Client* client,
  34                           scoped_refptr<base::SingleThreadTaskRunner> loop) = 0;
  35
  36   // Causes this instance to be deleted on the thread it is bound to.
  37   virtual void Release() = 0;
  38
  39   struct Deleter {
  40     inline void operator()(StreamTextureProxy* ptr) const { ptr->Release(); }
  41   };
  42 };
  43
  44 typedef scoped_ptr<StreamTextureProxy, StreamTextureProxy::Deleter>
  45     ScopedStreamTextureProxy;
  46
  47 class StreamTextureFactoryContextObserver {
  48  public:
  49   virtual ~StreamTextureFactoryContextObserver() {}
  50   virtual void ResetStreamTextureProxy() = 0;
  51 };
  52
  53 // Factory class for managing stream textures.
  54 class StreamTextureFactory : public base::RefCounted<StreamTextureFactory> {
  55  public:
  56   // Create the StreamTextureProxy object.
  57   virtual StreamTextureProxy* CreateProxy() = 0;
  58
  59   // Send an IPC message to the browser process to request a java surface
  60   // object for the given stream_id. After the the surface is created,
  61   // it will be passed back to the WebMediaPlayerAndroid object identified by
  62   // the player_id.
  63   virtual void EstablishPeer(int32 stream_id, int player_id) = 0;
  64
  65   // Creates a StreamTexture and returns its id.  Sets |*texture_id| to the
  66   // client-side id of the StreamTexture. The texture is produced into
  67   // a mailbox so it can be shipped in a VideoFrame.
  68   virtual unsigned CreateStreamTexture(unsigned texture_target,
  69                                        unsigned* texture_id,
  70                                        gpu::Mailbox* texture_mailbox) = 0;
  71
  72   // Set the streamTexture size for the given stream Id.
  73   virtual void SetStreamTextureSize(int32 texture_id,
  74                                     const gfx::Size& size) = 0;
  75
  76   virtual gpu::gles2::GLES2Interface* ContextGL() = 0;
  77
  78   virtual void AddObserver(StreamTextureFactoryContextObserver* obs) = 0;
  79   virtual void RemoveObserver(StreamTextureFactoryContextObserver* obs) = 0;
  80
  81  protected:
  82   friend class base::RefCounted<StreamTextureFactory>;
  83   virtual ~StreamTextureFactory() {}
  84 };
  85
  86 }  // namespace content
  87
  88 #endif  // CONTENT_RENDERER_MEDIA_ANDROID_STREAM_TEXTURE_FACTORY_H_