Home | History | Annotate | Download | only in android 
      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/message_loop/message_loop_proxy.h"
     11 #include "cc/layers/video_frame_provider.h"
     12 #include "gpu/command_buffer/common/mailbox.h"
     13 #include "ui/gfx/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::MessageLoopProxy> 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_
     89