Remove WebGraphicsContext3D getter from cc::ContextProvider

content/renderer/media/android/webmediaplayer_android.cc

 // Copyright 2013 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.
 
 #include "content/renderer/media/android/webmediaplayer_android.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "cc/layers/video_layer.h"
 #include "content/public/common/content_client.h"
 #include "content/renderer/media/android/proxy_media_keys.h"
 #include "content/renderer/media/android/renderer_demuxer_android.h"
 #include "content/renderer/media/android/renderer_media_player_manager.h"
 #include "content/renderer/media/crypto/key_systems.h"
 #include "content/renderer/media/webmediaplayer_delegate.h"
 #include "content/renderer/media/webmediaplayer_util.h"
 #include "content/renderer/render_thread_impl.h"
 #include "gpu/GLES2/gl2extchromium.h"
+#include "gpu/command_buffer/client/gles2_interface.h"
 #include "grit/content_resources.h"
 #include "media/base/android/media_player_android.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_frame.h"
 #include "net/base/mime_util.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
@@ skipping 10 matching lines @@
 #include "content/renderer/media/media_stream_client.h"
 #endif
 
 static const uint32 kGLTextureExternalOES = 0x8D65;
 
 using blink::WebMediaPlayer;
 using blink::WebSize;
 using blink::WebString;
 using blink::WebTimeRanges;
 using blink::WebURL;
+using gpu::gles2::GLES2Interface;
 using media::MediaPlayerAndroid;
 using media::VideoFrame;
 
 namespace {
 // Prefix for histograms related to Encrypted Media Extensions.
 const char* kMediaEme = "Media.EME.";
 }  // namespace
 
 namespace content {
 
@@ skipping 109 matching lines @@
 
   if (manager_) {
     manager_->DestroyPlayer(player_id_);
     manager_->UnregisterMediaPlayer(player_id_);
   }
 
   if (stream_id_)
     stream_texture_factory_->DestroyStreamTexture(texture_id_);
 
   if (remote_playback_texture_id_) {
-    blink::WebGraphicsContext3D* context =
-        stream_texture_factory_->Context3d();
-    if (context->makeContextCurrent())
-      context->deleteTexture(remote_playback_texture_id_);
+    if (GLES2Interface* gl = stream_texture_factory_->ContextGL())
+      gl->DeleteTextures(1, &remote_playback_texture_id_);
   }
 
   if (base::MessageLoop::current())
     base::MessageLoop::current()->RemoveDestructionObserver(this);
 
   if (player_type_ == MEDIA_PLAYER_TYPE_MEDIA_SOURCE && delegate_)
     delegate_->PlayerGone(this);
 
 #if defined(GOOGLE_TV)
   if (audio_renderer_) {
@@ skipping 714 matching lines @@
     audio_renderer_->Pause();
 #endif
   manager_->Pause(player_id_, is_media_related_action);
   UpdatePlayingState(false);
 }
 
 void WebMediaPlayerAndroid::DrawRemotePlaybackIcon() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!video_weblayer_)
     return;
-  blink::WebGraphicsContext3D* context = stream_texture_factory_->Context3d();
-  if (!context->makeContextCurrent())
+  GLES2Interface* gl = stream_texture_factory_->ContextGL();
+  if (!gl)
     return;
 
   // TODO(johnme): Should redraw this frame if the layer bounds change; but
   // there seems no easy way to listen for the layer resizing (as opposed to
   // OnVideoSizeChanged, which is when the frame sizes of the video file
   // change). Perhaps have to poll (on main thread of course)?
   gfx::Size video_size_css_px = video_weblayer_->bounds();
   float device_scale_factor = frame_->view()->deviceScaleFactor();
   // canvas_size will be the size in device pixels when pageScaleFactor == 1
   gfx::Size canvas_size(
@@ skipping 28 matching lines @@
   int icon_height = icon_width * icon_bitmap->height() / icon_bitmap->width();
   // Center the icon within the frame
   SkRect icon_rect = SkRect::MakeXYWH((canvas_size.width() - icon_width) / 2,
                                       (canvas_size.height() - icon_height) / 2,
                                       icon_width,
                                       icon_height);
   canvas.drawBitmapRectToRect(
       *icon_bitmap, NULL /* src */, icon_rect /* dest */, &paint);
 
   if (!remote_playback_texture_id_)
-    remote_playback_texture_id_ = context->createTexture();
-  unsigned texture_target = GL_TEXTURE_2D;
-  context->bindTexture(texture_target, remote_playback_texture_id_);
-  context->texParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  context->texParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  context->texParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  context->texParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    gl->GenTextures(1, &remote_playback_texture_id_);
+  GLuint texture_target = GL_TEXTURE_2D;
+  gl->BindTexture(texture_target, remote_playback_texture_id_);
+  gl->TexParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  gl->TexParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  gl->TexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  gl->TexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
   {
     SkAutoLockPixels lock(bitmap);
-    context->texImage2D(texture_target,
-                        0 /* level */,
-                        GL_RGBA /* internalformat */,
-                        bitmap.width(),
-                        bitmap.height(),
-                        0 /* border */,
-                        GL_RGBA /* format */,
-                        GL_UNSIGNED_BYTE /* type */,
-                        bitmap.getPixels());
+    gl->TexImage2D(texture_target,
+                   0 /* level */,
+                   GL_RGBA /* internalformat */,
+                   bitmap.width(),
+                   bitmap.height(),
+                   0 /* border */,
+                   GL_RGBA /* format */,
+                   GL_UNSIGNED_BYTE /* type */,
+                   bitmap.getPixels());
   }
 
   gpu::Mailbox texture_mailbox;
-  context->genMailboxCHROMIUM(texture_mailbox.name);
-  context->produceTextureCHROMIUM(texture_target, texture_mailbox.name);
-  context->flush();
-  unsigned texture_mailbox_sync_point = context->insertSyncPoint();
+  gl->GenMailboxCHROMIUM(texture_mailbox.name);
+  gl->ProduceTextureCHROMIUM(texture_target, texture_mailbox.name);
+  gl->Flush();
+  GLuint texture_mailbox_sync_point = gl->InsertSyncPointCHROMIUM();
 
   scoped_refptr<VideoFrame> new_frame = VideoFrame::WrapNativeTexture(
       make_scoped_ptr(new VideoFrame::MailboxHolder(
           texture_mailbox,
           texture_mailbox_sync_point,
           base::Bind(&WebMediaPlayerAndroid::OnReleaseRemotePlaybackTexture,
                      main_loop_,
                      weak_factory_.GetWeakPtr()))),
       texture_target,
       canvas_size /* coded_size */,
@@ skipping 419 matching lines @@
   demuxer_ = demuxer;
   destroy_demuxer_cb_ = destroy_demuxer_cb;
   return true;
 }
 #endif
 
 void WebMediaPlayerAndroid::DoReleaseRemotePlaybackTexture(uint32 sync_point) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(remote_playback_texture_id_);
 
-  blink::WebGraphicsContext3D* context =
-      stream_texture_factory_->Context3d();
+  GLES2Interface* gl = stream_texture_factory_->ContextGL();
 
   if (sync_point)
-    context->waitSyncPoint(sync_point);
-  context->deleteTexture(remote_playback_texture_id_);
+    gl->WaitSyncPointCHROMIUM(sync_point);
+  gl->DeleteTextures(1, &remote_playback_texture_id_);
   remote_playback_texture_id_ = 0;
 }
 
 void WebMediaPlayerAndroid::enterFullscreen() {
   if (manager_->CanEnterFullscreen(frame_)) {
     manager_->EnterFullscreen(player_id_);
     SetNeedsEstablishPeer(false);
   }
 }
 
 void WebMediaPlayerAndroid::exitFullscreen() {
   manager_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace content