Remove |cgl_context| from VTVideoDecodeAccelerator.

content/common/gpu/media/vt_video_decode_accelerator.cc

 // 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.
 
 #include <algorithm>
 
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sys_byteorder.h"
 #include "base/sys_info.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/version.h"
 #include "content/common/gpu/media/vt_video_decode_accelerator.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/limits.h"
+#include "ui/gl/gl_context.h"
 #include "ui/gl/scoped_binders.h"
 
 using content_common_gpu_media::kModuleVt;
 using content_common_gpu_media::InitializeStubs;
 using content_common_gpu_media::IsVtInitialized;
 using content_common_gpu_media::StubPathMap;
 
 #define NOTIFY_STATUS(name, status, session_failure)   \
     do {                                               \
       OSSTATUS_DLOG(ERROR, status) << name;            \
@@ skipping 33 matching lines @@
 // existing configuration when the configuration changes. This works around a
 // bug in VideoToolbox that results in corruption before Mac OS X 10.10.3. The
 // value is set in InitializeVideoToolbox().
 static bool g_enable_compatible_configuration_reuse = true;
 
 // Build an |image_config| dictionary for VideoToolbox initialization.
 static base::ScopedCFTypeRef<CFMutableDictionaryRef>
 BuildImageConfig(CMVideoDimensions coded_dimensions) {
   base::ScopedCFTypeRef<CFMutableDictionaryRef> image_config;
 
-  // TODO(sandersd): Does it save some work or memory to use 4:2:0?
+  // 4:2:2 is used over the native 4:2:0 because only 4:2:2 can be directly
+  // bound to a texture by CGLTexImageIOSurface2D().
   int32_t pixel_format = kCVPixelFormatType_422YpCbCr8;
 #define CFINT(i) CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &i)
   base::ScopedCFTypeRef<CFNumberRef> cf_pixel_format(CFINT(pixel_format));
   base::ScopedCFTypeRef<CFNumberRef> cf_width(CFINT(coded_dimensions.width));
   base::ScopedCFTypeRef<CFNumberRef> cf_height(CFINT(coded_dimensions.height));
 #undef CFINT
   if (!cf_pixel_format.get() || !cf_width.get() || !cf_height.get())
     return image_config;
 
   image_config.reset(
@@ skipping 191 matching lines @@
   if (lhs->pic_order_cnt != rhs->pic_order_cnt)
     return lhs->pic_order_cnt > rhs->pic_order_cnt;
   // If |pic_order_cnt| is the same, fall back on using the bitstream order.
   // TODO(sandersd): Assign a sequence number in Decode() and use that instead.
   // TODO(sandersd): Using the sequence number, ensure that frames older than
   // |kMaxReorderQueueSize| are ordered first, regardless of |pic_order_cnt|.
   return lhs->bitstream_id > rhs->bitstream_id;
 }
 
 VTVideoDecodeAccelerator::VTVideoDecodeAccelerator(
-    CGLContextObj cgl_context,
     const base::Callback<bool(void)>& make_context_current)
-    : cgl_context_(cgl_context),
-      make_context_current_(make_context_current),
+    : make_context_current_(make_context_current),
       client_(nullptr),
       state_(STATE_DECODING),
       format_(nullptr),
       session_(nullptr),
       last_sps_id_(-1),
       last_pps_id_(-1),
       gpu_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       decoder_thread_("VTDecoderThread"),
       weak_this_factory_(this) {
   DCHECK(!make_context_current_.is_null());
@@ skipping 687 matching lines @@
 
   if (!make_context_current_.Run()) {
     DLOG(ERROR) << "Failed to make GL context current";
     NotifyError(PLATFORM_FAILURE, SFT_PLATFORM_ERROR);
     return false;
   }
 
   glEnable(GL_TEXTURE_RECTANGLE_ARB);
   gfx::ScopedTextureBinder
       texture_binder(GL_TEXTURE_RECTANGLE_ARB, texture_ids_[picture_id]);
+  CGLContextObj cgl_context =
+      static_cast<CGLContextObj>(gfx::GLContext::GetCurrent()->GetHandle());
   CGLError status = CGLTexImageIOSurface2D(
-      cgl_context_,                 // ctx
+      cgl_context,                  // ctx
       GL_TEXTURE_RECTANGLE_ARB,     // target
       GL_RGB,                       // internal_format
       frame.coded_size.width(),     // width
       frame.coded_size.height(),    // height
       GL_YCBCR_422_APPLE,           // format
       GL_UNSIGNED_SHORT_8_8_APPLE,  // type
       surface,                      // io_surface
       0);                           // plane
+  glDisable(GL_TEXTURE_RECTANGLE_ARB);

[DaleCurtis, 2015/07/10 00:53:45]

Why the move to before the status is checked?

   if (status != kCGLNoError) {
     NOTIFY_STATUS("CGLTexImageIOSurface2D()", status, SFT_PLATFORM_ERROR);
     return false;
   }
-  glDisable(GL_TEXTURE_RECTANGLE_ARB);
 
   available_picture_ids_.pop_back();
   picture_bindings_[picture_id] = frame.image;
   client_->PictureReady(media::Picture(picture_id, frame.bitstream_id,
                                        gfx::Rect(frame.coded_size), false));
   return true;
 }
 
 void VTVideoDecodeAccelerator::NotifyError(
     Error vda_error_type,
@@ skipping 66 matching lines @@
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(16, 16);
     profile.max_resolution.SetSize(4096, 2160);
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 }  // namespace content