content/renderer/pepper/video_decoder_shim.cc

   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 #include "content/renderer/pepper/video_decoder_shim.h"
   6
   7 #include <GLES2/gl2.h>
   8 #include <GLES2/gl2ext.h>
   9 #include <GLES2/gl2extchromium.h>
  10
  11 #include "base/bind.h"
  12 #include "base/numerics/safe_conversions.h"
  13 #include "base/single_thread_task_runner.h"
  14 #include "content/public/renderer/render_thread.h"
  15 #include "content/renderer/pepper/pepper_video_decoder_host.h"
  16 #include "content/renderer/render_thread_impl.h"
  17 #include "gpu/command_buffer/client/gles2_implementation.h"
  18 #include "media/base/decoder_buffer.h"
  19 #include "media/base/limits.h"
  20 #include "media/base/video_decoder.h"
  21 #include "media/filters/ffmpeg_video_decoder.h"
  22 #include "media/filters/vpx_video_decoder.h"
  23 #include "media/video/picture.h"
  24 #include "media/video/video_decode_accelerator.h"
  25 #include "ppapi/c/pp_errors.h"
  26 #include "third_party/libyuv/include/libyuv.h"
  27 #include "webkit/common/gpu/context_provider_web_context.h"
  28
  29 namespace content {
  30
  31 struct VideoDecoderShim::PendingDecode {
  32   PendingDecode(uint32_t decode_id,
  33                 const scoped_refptr<media::DecoderBuffer>& buffer);
  34   ~PendingDecode();
  35
  36   const uint32_t decode_id;
  37   const scoped_refptr<media::DecoderBuffer> buffer;
  38 };
  39
  40 VideoDecoderShim::PendingDecode::PendingDecode(
  41     uint32_t decode_id,
  42     const scoped_refptr<media::DecoderBuffer>& buffer)
  43     : decode_id(decode_id), buffer(buffer) {
  44 }
  45
  46 VideoDecoderShim::PendingDecode::~PendingDecode() {
  47 }
  48
  49 struct VideoDecoderShim::PendingFrame {
  50   explicit PendingFrame(uint32_t decode_id);
  51   PendingFrame(uint32_t decode_id,
  52                const gfx::Size& coded_size,
  53                const gfx::Rect& visible_rect);
  54   ~PendingFrame();
  55
  56   const uint32_t decode_id;
  57   const gfx::Size coded_size;
  58   const gfx::Rect visible_rect;
  59   std::vector<uint8_t> argb_pixels;
  60
  61  private:
  62   // This could be expensive to copy, so guard against that.
  63   DISALLOW_COPY_AND_ASSIGN(PendingFrame);
  64 };
  65
  66 VideoDecoderShim::PendingFrame::PendingFrame(uint32_t decode_id)
  67     : decode_id(decode_id) {
  68 }
  69
  70 VideoDecoderShim::PendingFrame::PendingFrame(uint32_t decode_id,
  71                                              const gfx::Size& coded_size,
  72                                              const gfx::Rect& visible_rect)
  73     : decode_id(decode_id),
  74       coded_size(coded_size),
  75       visible_rect(visible_rect),
  76       argb_pixels(coded_size.width() * coded_size.height() * 4) {
  77 }
  78
  79 VideoDecoderShim::PendingFrame::~PendingFrame() {
  80 }
  81
  82 // DecoderImpl runs the underlying VideoDecoder on the media thread, receiving
  83 // calls from the VideoDecodeShim on the main thread and sending results back.
  84 // This class is constructed on the main thread, but used and destructed on the
  85 // media thread.
  86 class VideoDecoderShim::DecoderImpl {
  87  public:
  88   explicit DecoderImpl(const base::WeakPtr<VideoDecoderShim>& proxy);
  89   ~DecoderImpl();
  90
  91   void Initialize(media::VideoDecoderConfig config);
  92   void Decode(uint32_t decode_id, scoped_refptr<media::DecoderBuffer> buffer);
  93   void Reset();
  94   void Stop();
  95
  96  private:
  97   void OnPipelineStatus(media::PipelineStatus status);
  98   void DoDecode();
  99   void OnDecodeComplete(uint32_t decode_id, media::VideoDecoder::Status status);
 100   void OnOutputComplete(const scoped_refptr<media::VideoFrame>& frame);
 101   void OnResetComplete();
 102
 103   // WeakPtr is bound to main_message_loop_. Use only in shim callbacks.
 104   base::WeakPtr<VideoDecoderShim> shim_;
 105   scoped_ptr<media::VideoDecoder> decoder_;
 106   scoped_refptr<base::MessageLoopProxy> main_message_loop_;
 107   // Queue of decodes waiting for the decoder.
 108   typedef std::queue<PendingDecode> PendingDecodeQueue;
 109   PendingDecodeQueue pending_decodes_;
 110   int max_decodes_at_decoder_;
 111   int num_decodes_at_decoder_;
 112   // VideoDecoder returns pictures without information about the decode buffer
 113   // that generated it. Save the decode_id from the last decode that completed,
 114   // which is close for most decoders, which only decode one buffer at a time.
 115   uint32_t decode_id_;
 116 };
 117
 118 VideoDecoderShim::DecoderImpl::DecoderImpl(
 119     const base::WeakPtr<VideoDecoderShim>& proxy)
 120     : shim_(proxy),
 121       main_message_loop_(base::MessageLoopProxy::current()),
 122       max_decodes_at_decoder_(0),
 123       num_decodes_at_decoder_(0),
 124       decode_id_(0) {
 125 }
 126
 127 VideoDecoderShim::DecoderImpl::~DecoderImpl() {
 128   DCHECK(pending_decodes_.empty());
 129 }
 130
 131 void VideoDecoderShim::DecoderImpl::Initialize(
 132     media::VideoDecoderConfig config) {
 133   DCHECK(!decoder_);
 134 #if !defined(MEDIA_DISABLE_LIBVPX)
 135   if (config.codec() == media::kCodecVP9) {
 136     decoder_.reset(
 137         new media::VpxVideoDecoder(base::MessageLoopProxy::current()));
 138   } else
 139 #endif
 140   {
 141     scoped_ptr<media::FFmpegVideoDecoder> ffmpeg_video_decoder(
 142         new media::FFmpegVideoDecoder(base::MessageLoopProxy::current()));
 143     ffmpeg_video_decoder->set_decode_nalus(true);
 144     decoder_ = ffmpeg_video_decoder.Pass();
 145   }
 146   max_decodes_at_decoder_ = decoder_->GetMaxDecodeRequests();
 147   // We can use base::Unretained() safely in decoder callbacks because
 148   // |decoder_| is owned by DecoderImpl. During Stop(), the |decoder_| will be
 149   // destroyed and all outstanding callbacks will be fired.
 150   decoder_->Initialize(
 151       config,
 152       true /* low_delay */,
 153       base::Bind(&VideoDecoderShim::DecoderImpl::OnPipelineStatus,
 154                  base::Unretained(this)),
 155       base::Bind(&VideoDecoderShim::DecoderImpl::OnOutputComplete,
 156                  base::Unretained(this)));
 157 }
 158
 159 void VideoDecoderShim::DecoderImpl::Decode(
 160     uint32_t decode_id,
 161     scoped_refptr<media::DecoderBuffer> buffer) {
 162   DCHECK(decoder_);
 163   pending_decodes_.push(PendingDecode(decode_id, buffer));
 164   DoDecode();
 165 }
 166
 167 void VideoDecoderShim::DecoderImpl::Reset() {
 168   DCHECK(decoder_);
 169   // Abort all pending decodes.
 170   while (!pending_decodes_.empty()) {
 171     const PendingDecode& decode = pending_decodes_.front();
 172     scoped_ptr<PendingFrame> pending_frame(new PendingFrame(decode.decode_id));
 173     main_message_loop_->PostTask(FROM_HERE,
 174                                  base::Bind(&VideoDecoderShim::OnDecodeComplete,
 175                                             shim_,
 176                                             media::VideoDecoder::kAborted,
 177                                             decode.decode_id));
 178     pending_decodes_.pop();
 179   }
 180   decoder_->Reset(base::Bind(&VideoDecoderShim::DecoderImpl::OnResetComplete,
 181                              base::Unretained(this)));
 182 }
 183
 184 void VideoDecoderShim::DecoderImpl::Stop() {
 185   DCHECK(decoder_);
 186   // Clear pending decodes now. We don't want OnDecodeComplete to call DoDecode
 187   // again.
 188   while (!pending_decodes_.empty())
 189     pending_decodes_.pop();
 190   decoder_.reset();
 191   // This instance is deleted once we exit this scope.
 192 }
 193
 194 void VideoDecoderShim::DecoderImpl::OnPipelineStatus(
 195     media::PipelineStatus status) {
 196   int32_t result;
 197   switch (status) {
 198     case media::PIPELINE_OK:
 199       result = PP_OK;
 200       break;
 201     case media::DECODER_ERROR_NOT_SUPPORTED:
 202       result = PP_ERROR_NOTSUPPORTED;
 203       break;
 204     default:
 205       result = PP_ERROR_FAILED;
 206       break;
 207   }
 208
 209   // Calculate how many textures the shim should create.
 210   uint32_t shim_texture_pool_size =
 211       max_decodes_at_decoder_ + media::limits::kMaxVideoFrames;
 212   main_message_loop_->PostTask(
 213       FROM_HERE,
 214       base::Bind(&VideoDecoderShim::OnInitializeComplete,
 215                  shim_,
 216                  result,
 217                  shim_texture_pool_size));
 218 }
 219
 220 void VideoDecoderShim::DecoderImpl::DoDecode() {
 221   while (!pending_decodes_.empty() &&
 222          num_decodes_at_decoder_ < max_decodes_at_decoder_) {
 223     num_decodes_at_decoder_++;
 224     const PendingDecode& decode = pending_decodes_.front();
 225     decoder_->Decode(
 226         decode.buffer,
 227         base::Bind(&VideoDecoderShim::DecoderImpl::OnDecodeComplete,
 228                    base::Unretained(this),
 229                    decode.decode_id));
 230     pending_decodes_.pop();
 231   }
 232 }
 233
 234 void VideoDecoderShim::DecoderImpl::OnDecodeComplete(
 235     uint32_t decode_id,
 236     media::VideoDecoder::Status status) {
 237   num_decodes_at_decoder_--;
 238   decode_id_ = decode_id;
 239
 240   int32_t result;
 241   switch (status) {
 242     case media::VideoDecoder::kOk:
 243     case media::VideoDecoder::kAborted:
 244       result = PP_OK;
 245       break;
 246     case media::VideoDecoder::kDecodeError:
 247       result = PP_ERROR_RESOURCE_FAILED;
 248       break;
 249     default:
 250       NOTREACHED();
 251       result = PP_ERROR_FAILED;
 252       break;
 253   }
 254
 255   main_message_loop_->PostTask(
 256       FROM_HERE,
 257       base::Bind(
 258           &VideoDecoderShim::OnDecodeComplete, shim_, result, decode_id));
 259
 260   DoDecode();
 261 }
 262
 263 void VideoDecoderShim::DecoderImpl::OnOutputComplete(
 264     const scoped_refptr<media::VideoFrame>& frame) {
 265   scoped_ptr<PendingFrame> pending_frame;
 266   if (!frame->end_of_stream()) {
 267     pending_frame.reset(new PendingFrame(
 268         decode_id_, frame->coded_size(), frame->visible_rect()));
 269     // Convert the VideoFrame pixels to ABGR to match VideoDecodeAccelerator.
 270     libyuv::I420ToABGR(frame->data(media::VideoFrame::kYPlane),
 271                        frame->stride(media::VideoFrame::kYPlane),
 272                        frame->data(media::VideoFrame::kUPlane),
 273                        frame->stride(media::VideoFrame::kUPlane),
 274                        frame->data(media::VideoFrame::kVPlane),
 275                        frame->stride(media::VideoFrame::kVPlane),
 276                        &pending_frame->argb_pixels.front(),
 277                        frame->coded_size().width() * 4,
 278                        frame->coded_size().width(),
 279                        frame->coded_size().height());
 280   } else {
 281     pending_frame.reset(new PendingFrame(decode_id_));
 282   }
 283
 284   main_message_loop_->PostTask(FROM_HERE,
 285                                base::Bind(&VideoDecoderShim::OnOutputComplete,
 286                                           shim_,
 287                                           base::Passed(&pending_frame)));
 288 }
 289
 290 void VideoDecoderShim::DecoderImpl::OnResetComplete() {
 291   main_message_loop_->PostTask(
 292       FROM_HERE, base::Bind(&VideoDecoderShim::OnResetComplete, shim_));
 293 }
 294
 295 VideoDecoderShim::VideoDecoderShim(PepperVideoDecoderHost* host)
 296     : state_(UNINITIALIZED),
 297       host_(host),
 298       media_task_runner_(
 299           RenderThreadImpl::current()->GetMediaThreadTaskRunner()),
 300       context_provider_(
 301           RenderThreadImpl::current()->SharedMainThreadContextProvider()),
 302       texture_pool_size_(0),
 303       num_pending_decodes_(0),
 304       weak_ptr_factory_(this) {
 305   DCHECK(host_);
 306   DCHECK(media_task_runner_.get());
 307   DCHECK(context_provider_.get());
 308   decoder_impl_.reset(new DecoderImpl(weak_ptr_factory_.GetWeakPtr()));
 309 }
 310
 311 VideoDecoderShim::~VideoDecoderShim() {
 312   DCHECK(RenderThreadImpl::current());
 313   // Delete any remaining textures.
 314   TextureIdMap::iterator it = texture_id_map_.begin();
 315   for (; it != texture_id_map_.end(); ++it)
 316     DeleteTexture(it->second);
 317   texture_id_map_.clear();
 318
 319   FlushCommandBuffer();
 320
 321   weak_ptr_factory_.InvalidateWeakPtrs();
 322   // No more callbacks from the delegate will be received now.
 323
 324   // The callback now holds the only reference to the DecoderImpl, which will be
 325   // deleted when Stop completes.
 326   media_task_runner_->PostTask(
 327       FROM_HERE,
 328       base::Bind(&VideoDecoderShim::DecoderImpl::Stop,
 329                  base::Owned(decoder_impl_.release())));
 330 }
 331
 332 bool VideoDecoderShim::Initialize(
 333     media::VideoCodecProfile profile,
 334     media::VideoDecodeAccelerator::Client* client) {
 335   DCHECK_EQ(client, host_);
 336   DCHECK(RenderThreadImpl::current());
 337   DCHECK_EQ(state_, UNINITIALIZED);
 338   media::VideoCodec codec = media::kUnknownVideoCodec;
 339   if (profile <= media::H264PROFILE_MAX)
 340     codec = media::kCodecH264;
 341   else if (profile <= media::VP8PROFILE_MAX)
 342     codec = media::kCodecVP8;
 343   else if (profile <= media::VP9PROFILE_MAX)
 344     codec = media::kCodecVP9;
 345   DCHECK_NE(codec, media::kUnknownVideoCodec);
 346
 347   media::VideoDecoderConfig config(
 348       codec,
 349       profile,
 350       media::VideoFrame::YV12,
 351       gfx::Size(32, 24),  // Small sizes that won't fail.
 352       gfx::Rect(32, 24),
 353       gfx::Size(32, 24),
 354       NULL /* extra_data */,  // TODO(bbudge) Verify this isn't needed.
 355       0 /* extra_data_size */,
 356       false /* decryption */);
 357
 358   media_task_runner_->PostTask(
 359       FROM_HERE,
 360       base::Bind(&VideoDecoderShim::DecoderImpl::Initialize,
 361                  base::Unretained(decoder_impl_.get()),
 362                  config));
 363   // Return success, even though we are asynchronous, to mimic
 364   // media::VideoDecodeAccelerator.
 365   return true;
 366 }
 367
 368 void VideoDecoderShim::Decode(const media::BitstreamBuffer& bitstream_buffer) {
 369   DCHECK(RenderThreadImpl::current());
 370   DCHECK_EQ(state_, DECODING);
 371
 372   // We need the address of the shared memory, so we can copy the buffer.
 373   const uint8_t* buffer = host_->DecodeIdToAddress(bitstream_buffer.id());
 374   DCHECK(buffer);
 375
 376   media_task_runner_->PostTask(
 377       FROM_HERE,
 378       base::Bind(
 379           &VideoDecoderShim::DecoderImpl::Decode,
 380           base::Unretained(decoder_impl_.get()),
 381           bitstream_buffer.id(),
 382           media::DecoderBuffer::CopyFrom(buffer, bitstream_buffer.size())));
 383   num_pending_decodes_++;
 384 }
 385
 386 void VideoDecoderShim::AssignPictureBuffers(
 387     const std::vector<media::PictureBuffer>& buffers) {
 388   DCHECK(RenderThreadImpl::current());
 389   DCHECK_EQ(state_, DECODING);
 390   if (buffers.empty()) {
 391     NOTREACHED();
 392     return;
 393   }
 394   DCHECK_EQ(buffers.size(), pending_texture_mailboxes_.size());
 395   GLuint num_textures = base::checked_cast<GLuint>(buffers.size());
 396   std::vector<uint32_t> local_texture_ids(num_textures);
 397   gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
 398   for (uint32_t i = 0; i < num_textures; i++) {
 399     local_texture_ids[i] = gles2->CreateAndConsumeTextureCHROMIUM(
 400         GL_TEXTURE_2D, pending_texture_mailboxes_[i].name);
 401     // Map the plugin texture id to the local texture id.
 402     uint32_t plugin_texture_id = buffers[i].texture_id();
 403     texture_id_map_[plugin_texture_id] = local_texture_ids[i];
 404     available_textures_.insert(plugin_texture_id);
 405   }
 406   pending_texture_mailboxes_.clear();
 407   SendPictures();
 408 }
 409
 410 void VideoDecoderShim::ReusePictureBuffer(int32 picture_buffer_id) {
 411   DCHECK(RenderThreadImpl::current());
 412   uint32_t texture_id = static_cast<uint32_t>(picture_buffer_id);
 413   if (textures_to_dismiss_.find(texture_id) != textures_to_dismiss_.end()) {
 414     DismissTexture(texture_id);
 415   } else if (texture_id_map_.find(texture_id) != texture_id_map_.end()) {
 416     available_textures_.insert(texture_id);
 417     SendPictures();
 418   } else {
 419     NOTREACHED();
 420   }
 421 }
 422
 423 void VideoDecoderShim::Flush() {
 424   DCHECK(RenderThreadImpl::current());
 425   DCHECK_EQ(state_, DECODING);
 426   state_ = FLUSHING;
 427 }
 428
 429 void VideoDecoderShim::Reset() {
 430   DCHECK(RenderThreadImpl::current());
 431   DCHECK_EQ(state_, DECODING);
 432   state_ = RESETTING;
 433   media_task_runner_->PostTask(
 434       FROM_HERE,
 435       base::Bind(&VideoDecoderShim::DecoderImpl::Reset,
 436                  base::Unretained(decoder_impl_.get())));
 437 }
 438
 439 void VideoDecoderShim::Destroy() {
 440   // This will be called, but our destructor does the actual work.
 441 }
 442
 443 void VideoDecoderShim::OnInitializeComplete(int32_t result,
 444                                             uint32_t texture_pool_size) {
 445   DCHECK(RenderThreadImpl::current());
 446   DCHECK(host_);
 447
 448   if (result == PP_OK) {
 449     state_ = DECODING;
 450     texture_pool_size_ = texture_pool_size;
 451   }
 452
 453   host_->OnInitializeComplete(result);
 454 }
 455
 456 void VideoDecoderShim::OnDecodeComplete(int32_t result, uint32_t decode_id) {
 457   DCHECK(RenderThreadImpl::current());
 458   DCHECK(host_);
 459
 460   if (result == PP_ERROR_RESOURCE_FAILED) {
 461     host_->NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
 462     return;
 463   }
 464
 465   num_pending_decodes_--;
 466   completed_decodes_.push(decode_id);
 467
 468   // If frames are being queued because we're out of textures, don't notify
 469   // the host that decode has completed. This exerts "back pressure" to keep
 470   // the host from sending buffers that will cause pending_frames_ to grow.
 471   if (pending_frames_.empty())
 472     NotifyCompletedDecodes();
 473 }
 474
 475 void VideoDecoderShim::OnOutputComplete(scoped_ptr<PendingFrame> frame) {
 476   DCHECK(RenderThreadImpl::current());
 477   DCHECK(host_);
 478
 479   if (!frame->argb_pixels.empty()) {
 480     if (texture_size_ != frame->coded_size) {
 481       // If the size has changed, all current textures must be dismissed. Add
 482       // all textures to |textures_to_dismiss_| and dismiss any that aren't in
 483       // use by the plugin. We will dismiss the rest as they are recycled.
 484       for (TextureIdMap::const_iterator it = texture_id_map_.begin();
 485            it != texture_id_map_.end();
 486            ++it) {
 487         textures_to_dismiss_.insert(it->second);
 488       }
 489       for (TextureIdSet::const_iterator it = available_textures_.begin();
 490            it != available_textures_.end();
 491            ++it) {
 492         DismissTexture(*it);
 493       }
 494       available_textures_.clear();
 495       FlushCommandBuffer();
 496
 497       DCHECK(pending_texture_mailboxes_.empty());
 498       for (uint32_t i = 0; i < texture_pool_size_; i++)
 499         pending_texture_mailboxes_.push_back(gpu::Mailbox::Generate());
 500
 501       host_->RequestTextures(texture_pool_size_,
 502                              frame->coded_size,
 503                              GL_TEXTURE_2D,
 504                              pending_texture_mailboxes_);
 505       texture_size_ = frame->coded_size;
 506     }
 507
 508     pending_frames_.push(linked_ptr<PendingFrame>(frame.release()));
 509     SendPictures();
 510   }
 511 }
 512
 513 void VideoDecoderShim::SendPictures() {
 514   DCHECK(RenderThreadImpl::current());
 515   DCHECK(host_);
 516   while (!pending_frames_.empty() && !available_textures_.empty()) {
 517     const linked_ptr<PendingFrame>& frame = pending_frames_.front();
 518
 519     TextureIdSet::iterator it = available_textures_.begin();
 520     uint32_t texture_id = *it;
 521     available_textures_.erase(it);
 522
 523     uint32_t local_texture_id = texture_id_map_[texture_id];
 524     gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
 525     gles2->ActiveTexture(GL_TEXTURE0);
 526     gles2->BindTexture(GL_TEXTURE_2D, local_texture_id);
 527     gles2->TexImage2D(GL_TEXTURE_2D,
 528                       0,
 529                       GL_RGBA,
 530                       texture_size_.width(),
 531                       texture_size_.height(),
 532                       0,
 533                       GL_RGBA,
 534                       GL_UNSIGNED_BYTE,
 535                       &frame->argb_pixels.front());
 536
 537     host_->PictureReady(
 538         media::Picture(texture_id, frame->decode_id, frame->visible_rect));
 539     pending_frames_.pop();
 540   }
 541
 542   FlushCommandBuffer();
 543
 544   if (pending_frames_.empty()) {
 545     // If frames aren't backing up, notify the host of any completed decodes so
 546     // it can send more buffers.
 547     NotifyCompletedDecodes();
 548
 549     if (state_ == FLUSHING && !num_pending_decodes_) {
 550       state_ = DECODING;
 551       host_->NotifyFlushDone();
 552     }
 553   }
 554 }
 555
 556 void VideoDecoderShim::OnResetComplete() {
 557   DCHECK(RenderThreadImpl::current());
 558   DCHECK(host_);
 559
 560   while (!pending_frames_.empty())
 561     pending_frames_.pop();
 562   NotifyCompletedDecodes();
 563
 564   // Dismiss any old textures now.
 565   while (!textures_to_dismiss_.empty())
 566     DismissTexture(*textures_to_dismiss_.begin());
 567
 568   state_ = DECODING;
 569   host_->NotifyResetDone();
 570 }
 571
 572 void VideoDecoderShim::NotifyCompletedDecodes() {
 573   while (!completed_decodes_.empty()) {
 574     host_->NotifyEndOfBitstreamBuffer(completed_decodes_.front());
 575     completed_decodes_.pop();
 576   }
 577 }
 578
 579 void VideoDecoderShim::DismissTexture(uint32_t texture_id) {
 580   DCHECK(host_);
 581   textures_to_dismiss_.erase(texture_id);
 582   DCHECK(texture_id_map_.find(texture_id) != texture_id_map_.end());
 583   DeleteTexture(texture_id_map_[texture_id]);
 584   texture_id_map_.erase(texture_id);
 585   host_->DismissPictureBuffer(texture_id);
 586 }
 587
 588 void VideoDecoderShim::DeleteTexture(uint32_t texture_id) {
 589   gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
 590   gles2->DeleteTextures(1, &texture_id);
 591 }
 592
 593 void VideoDecoderShim::FlushCommandBuffer() {
 594   context_provider_->ContextGL()->Flush();
 595 }
 596
 597 }  // namespace content