Fix OnChannelError() in StreamTextureHost

content/renderer/media/android/stream_texture_factory.h

 // Copyright 2014 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 CONTENT_RENDERER_MEDIA_ANDROID_STREAM_TEXTURE_FACTORY_H_
 #define CONTENT_RENDERER_MEDIA_ANDROID_STREAM_TEXTURE_FACTORY_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 49 matching lines @@
   // Asks the StreamTexture to forward its SurfaceTexture to the
   // ScopedSurfaceRequestManager, using the gpu::ScopedSurfaceRequestConduit.
   void ForwardStreamTextureForSurfaceRequest(
       const base::UnguessableToken& request_token);
 
   struct Deleter {
     inline void operator()(StreamTextureProxy* ptr) const { ptr->Release(); }
   };
  private:
   friend class StreamTextureFactory;
-  explicit StreamTextureProxy(StreamTextureHost* host);
+  explicit StreamTextureProxy(std::unique_ptr<StreamTextureHost> host);
 
   void BindOnThread();
   void Release();
 
   const std::unique_ptr<StreamTextureHost> host_;
 
   // Protects access to |received_frame_cb_| and |task_runner_|.
   base::Lock lock_;
   base::Closure received_frame_cb_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
@@ skipping 12 matching lines @@
       scoped_refptr<ContextProviderCommandBuffer> context_provider);
 
   // Create the StreamTextureProxy object. This internally calls
   // CreateSteamTexture with the recieved arguments. CreateSteamTexture
   // generates a texture and stores it in  *texture_id, the texture is produced
   // into a mailbox so it can be shipped in a VideoFrame, it creates a
   // gpu::StreamTexture and returns its route_id. If this route_id is  invalid
   // nullptr is returned and *texture_id will be set to 0. If the route_id is
   // valid it returns StreamTextureProxy object. The caller needs to take care
   // of cleaning up the texture_id.
-  StreamTextureProxy* CreateProxy(unsigned texture_target,
-                                  unsigned* texture_id,
-                                  gpu::Mailbox* texture_mailbox);
+  ScopedStreamTextureProxy CreateProxy(unsigned texture_target,
+                                       unsigned* texture_id,
+                                       gpu::Mailbox* texture_mailbox);
 
   gpu::gles2::GLES2Interface* ContextGL();
 
  private:
   friend class base::RefCounted<StreamTextureFactory>;
   StreamTextureFactory(
       scoped_refptr<ContextProviderCommandBuffer> context_provider);
   ~StreamTextureFactory();
   // Creates a gpu::StreamTexture and returns its id.  Sets |*texture_id| to the
   // client-side id of the gpu::StreamTexture. The texture is produced into
   // a mailbox so it can be shipped in a VideoFrame.
   unsigned CreateStreamTexture(unsigned texture_target,
                                unsigned* texture_id,
                                gpu::Mailbox* texture_mailbox);
 
   scoped_refptr<ContextProviderCommandBuffer> context_provider_;
   scoped_refptr<gpu::GpuChannelHost> channel_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StreamTextureFactory);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_ANDROID_STREAM_TEXTURE_FACTORY_H_