CHECK that video textures and processors are created on right context.

ui/gl/gl_image_dxgi.cc

 // Copyright 2017 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 "ui/gl/gl_image_dxgi.h"
 
 #include "third_party/khronos/EGL/egl.h"
 #include "third_party/khronos/EGL/eglext.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_image.h"
@@ skipping 100 matching lines @@
   if (!result)
     return false;
   result = eglStreamConsumerAcquireKHR(egl_display, stream_);
   if (!result)
     return false;
 
   d3d11_device_.CopyTo(video_device_.GetAddressOf());
   base::win::ScopedComPtr<ID3D11DeviceContext> context;
   d3d11_device_->GetImmediateContext(context.GetAddressOf());
   context.CopyTo(video_context_.GetAddressOf());
+
+  base::win::ScopedComPtr<ID3D10Multithread> multithread;
+  d3d11_device_.CopyTo(multithread.GetAddressOf());
+  CHECK(multithread->GetMultithreadProtected());
   return true;
 }
 
 bool CopyingGLImageDXGI::InitializeVideoProcessor(
     const base::win::ScopedComPtr<ID3D11VideoProcessor>& video_processor,
     const base::win::ScopedComPtr<ID3D11VideoProcessorEnumerator>& enumerator) {
   output_view_.Reset();
 
+  base::win::ScopedComPtr<ID3D11Device> processor_device;
+  video_processor->GetDevice(processor_device.GetAddressOf());
+  CHECK_EQ(d3d11_device_.Get(), processor_device.Get());
+
   d3d11_processor_ = video_processor;
   enumerator_ = enumerator;
   D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC output_view_desc = {
       D3D11_VPOV_DIMENSION_TEXTURE2D};
   output_view_desc.Texture2D.MipSlice = 0;
   base::win::ScopedComPtr<ID3D11VideoProcessorOutputView> output_view;
   HRESULT hr = video_device_->CreateVideoProcessorOutputView(
       decoder_copy_texture_.Get(), enumerator_.Get(), &output_view_desc,
       output_view_.GetAddressOf());
   if (FAILED(hr)) {
     DLOG(ERROR) << "Failed to get output view";
     return false;
   }
   return true;
 }
 
 void CopyingGLImageDXGI::UnbindFromTexture() {
   copied_ = false;
 }
 
 bool CopyingGLImageDXGI::BindTexImage(unsigned target) {
   if (copied_)
     return true;
 
+  CHECK(video_device_);
+  base::win::ScopedComPtr<ID3D11Device> texture_device;
+  texture_->GetDevice(texture_device.GetAddressOf());
+  CHECK_EQ(d3d11_device_.Get(), texture_device.Get());
+
   D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC input_view_desc = {0};
   input_view_desc.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
   input_view_desc.Texture2D.ArraySlice = (UINT)level_;
   input_view_desc.Texture2D.MipSlice = 0;
   base::win::ScopedComPtr<ID3D11VideoProcessorInputView> input_view;
   HRESULT hr = video_device_->CreateVideoProcessorInputView(
       texture_.Get(), enumerator_.Get(), &input_view_desc,
       input_view.GetAddressOf());
   if (FAILED(hr)) {
     DLOG(ERROR) << "Failed to create video processor input view.";
@@ skipping 10 matching lines @@
     DLOG(ERROR) << "Failed to process video";
     return false;
   }
   copied_ = true;
   return true;
 }
 
 CopyingGLImageDXGI::~CopyingGLImageDXGI() {}
 
 }  // namespace gl