Revert of Make Android StreamTexture implement GLStreamTextureImage

cc/layers/video_frame_provider_client_impl.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 "cc/layers/video_frame_provider_client_impl.h"
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/video_layer_impl.h"
 #include "media/base/video_frame.h"
@@ skipping 14 matching lines @@
       client_(client),
       active_video_layer_(nullptr),
       stopped_(false),
       rendering_(false),
       needs_put_current_frame_(false) {
   // This only happens during a commit on the compositor thread while the main
   // thread is blocked. That makes this a thread-safe call to set the video
   // frame provider client that does not require a lock. The same is true of
   // the call to Stop().
   provider_->SetVideoFrameProviderClient(this);
+
+  // This matrix is the default transformation for stream textures, and flips
+  // on the Y axis.
+  stream_texture_matrix_ = gfx::Transform(
+      1.0, 0.0, 0.0, 0.0,
+      0.0, -1.0, 0.0, 1.0,
+      0.0, 0.0, 1.0, 0.0,
+      0.0, 0.0, 0.0, 1.0);
 }
 
 VideoFrameProviderClientImpl::~VideoFrameProviderClientImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(stopped_);
 }
 
 VideoLayerImpl* VideoFrameProviderClientImpl::ActiveVideoLayer() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return active_video_layer_;
@@ skipping 45 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   provider_lock_.AssertAcquired();
   provider_lock_.Release();
 }
 
 bool VideoFrameProviderClientImpl::HasCurrentFrame() {
   base::AutoLock locker(provider_lock_);
   return provider_ && provider_->HasCurrentFrame();
 }
 
+const gfx::Transform& VideoFrameProviderClientImpl::StreamTextureMatrix()
+    const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return stream_texture_matrix_;
+}
+
 void VideoFrameProviderClientImpl::StopUsingProvider() {
   {
     // Block the provider from shutting down until this client is done
     // using the frame.
     base::AutoLock locker(provider_lock_);
     provider_ = nullptr;
   }
   if (rendering_)
     StopRendering();
 }
@@ skipping 20 matching lines @@
   TRACE_EVENT1("cc",
                "VideoFrameProviderClientImpl::DidReceiveFrame",
                "active_video_layer",
                !!active_video_layer_);
   DCHECK(thread_checker_.CalledOnValidThread());
   needs_put_current_frame_ = true;
   if (active_video_layer_)
     active_video_layer_->SetNeedsRedraw();
 }
 
+void VideoFrameProviderClientImpl::DidUpdateMatrix(const float* matrix) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  stream_texture_matrix_ = gfx::Transform(
+      matrix[0], matrix[4], matrix[8], matrix[12],
+      matrix[1], matrix[5], matrix[9], matrix[13],
+      matrix[2], matrix[6], matrix[10], matrix[14],
+      matrix[3], matrix[7], matrix[11], matrix[15]);
+  if (active_video_layer_)
+    active_video_layer_->SetNeedsRedraw();
+}
+
 void VideoFrameProviderClientImpl::OnBeginFrame(const BeginFrameArgs& args) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(rendering_);
   DCHECK(!stopped_);
 
   TRACE_EVENT0("cc", "VideoFrameProviderClientImpl::OnBeginFrame");
   {
     base::AutoLock locker(provider_lock_);
 
     // We use frame_time + interval here because that is the estimated time at
@@ skipping 14 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   {
     base::AutoLock locker(provider_lock_);
     if (provider_ && needs_put_current_frame_)
       provider_->PutCurrentFrame();
   }
   needs_put_current_frame_ = false;
 }
 
 }  // namespace cc