Convert plugin and GPU process to brokered handle duplication.

content/common/gpu/media/dxva_video_decode_accelerator.cc

 // Copyright (c) 2012 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/common/gpu/media/dxva_video_decode_accelerator.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
@@ skipping 124 matching lines @@
   RETURN_ON_HR_FAILURE(hr, "Failed to unlock buffer", NULL);
 
   hr = buffer->SetCurrentLength(size);
   RETURN_ON_HR_FAILURE(hr, "Failed to set buffer length", NULL);
 
   return sample.Detach();
 }
 
 static IMFSample* CreateSampleFromInputBuffer(
     const media::BitstreamBuffer& bitstream_buffer,
-    base::ProcessHandle renderer_process,
     DWORD stream_size,
     DWORD alignment) {
-  HANDLE shared_memory_handle = NULL;
-  RETURN_ON_FAILURE(::DuplicateHandle(renderer_process,
-                                      bitstream_buffer.handle(),
-                                      base::GetCurrentProcessHandle(),
-                                      &shared_memory_handle,
-                                      0,
-                                      FALSE,
-                                      DUPLICATE_SAME_ACCESS),
-                     "Duplicate handle failed", NULL);
-
-  base::SharedMemory shm(shared_memory_handle, true);
+  base::SharedMemory shm(bitstream_buffer.handle(), true);
   RETURN_ON_FAILURE(shm.Map(bitstream_buffer.size()),
                     "Failed in base::SharedMemory::Map", NULL);
 
   return CreateInputSample(reinterpret_cast<const uint8*>(shm.memory()),
                            bitstream_buffer.size(),
                            stream_size,
                            alignment);
 }
 
 // Helper function to read the bitmap from the D3D surface passed in.
@@ skipping 329 matching lines @@
   hr = device_manager_->ResetDevice(device_, dev_manager_reset_token_);
   RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
 
   hr = device_->CreateQuery(D3DQUERYTYPE_EVENT, &query_);
   RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device query", false);
 
   return true;
 }
 
 DXVAVideoDecodeAccelerator::DXVAVideoDecodeAccelerator(
-    media::VideoDecodeAccelerator::Client* client,
-    base::ProcessHandle renderer_process)
+    media::VideoDecodeAccelerator::Client* client)
     : client_(client),
       egl_config_(NULL),
       state_(kUninitialized),
       pictures_requested_(false),
-      renderer_process_(renderer_process),
       last_input_buffer_id_(-1),
       inputs_before_decode_(0) {
   memset(&input_stream_info_, 0, sizeof(input_stream_info_));
   memset(&output_stream_info_, 0, sizeof(output_stream_info_));
 }
 
 DXVAVideoDecodeAccelerator::~DXVAVideoDecodeAccelerator() {
   client_ = NULL;
 }
 
@@ skipping 28 matching lines @@
 
 void DXVAVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK(CalledOnValidThread());
 
   RETURN_AND_NOTIFY_ON_FAILURE((state_ == kNormal || state_ == kStopped),
       "Invalid state: " << state_, ILLEGAL_STATE,);
 
   base::win::ScopedComPtr<IMFSample> sample;
   sample.Attach(CreateSampleFromInputBuffer(bitstream_buffer,
-                                            renderer_process_,
                                             input_stream_info_.cbSize,
                                             input_stream_info_.cbAlignment));
   RETURN_AND_NOTIFY_ON_FAILURE(sample, "Failed to create input sample",
                                PLATFORM_FAILURE,);
   if (!inputs_before_decode_) {
     TRACE_EVENT_BEGIN_ETW("DXVAVideoDecodeAccelerator.Decoding", this, "");
   }
   inputs_before_decode_++;
 
   RETURN_AND_NOTIFY_ON_FAILURE(
@@ skipping 458 matching lines @@
                                    gfx::Size(width, height));
   }
 }
 
 void DXVAVideoDecodeAccelerator::NotifyPictureReady(
     const media::Picture& picture) {
   // This task could execute after the decoder has been torn down.
   if (state_ != kUninitialized && client_)
     client_->PictureReady(picture);
 }