Use InterlockedAdd(0) to get the current state in DXVAVideoDecodeAccelerator::GetState

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 1439 matching lines @@
     int32 picture_buffer_id) {
   OutputBuffers::iterator it = stale_output_picture_buffers_.find(
       picture_buffer_id);
   DCHECK(it != stale_output_picture_buffers_.end());
   DVLOG(1) << "Dismissing picture id: " << it->second->id();
   client_->DismissPictureBuffer(it->second->id());
   stale_output_picture_buffers_.erase(it);
 }
 
 DXVAVideoDecodeAccelerator::State
-DXVAVideoDecodeAccelerator::GetState() const {
-  State state = kUninitialized;
-  ::InterlockedExchange(reinterpret_cast<long*>(&state),
-                        state_);
+DXVAVideoDecodeAccelerator::GetState() {
+  DCHECK(sizeof(State) == sizeof(long));

[brucedawson, 2014/12/12 20:50:18]

You shouldn't use DCHECK here -- use static_assert instead, as in:

static_assert(sizeof(State) == sizeof(long), "mismatched type sizes");

This ensures that any failures are caught at compile-time, for debug and release
builds. It also ensures that there is zero overhead.

[ananta, 2014/12/12 20:58:58]

Thanks. done.

+  State state = static_cast<State>(
+      InterlockedAdd(reinterpret_cast<volatile long*>(&state_), 0));
   return state;
 }
 
 void DXVAVideoDecodeAccelerator::SetState(State new_state) {
   if (!main_thread_task_runner_->BelongsToCurrentThread()) {
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::SetState,
                    weak_this_factory_.GetWeakPtr(),
                    new_state));
     return;
   }
-  ::InterlockedCompareExchange(reinterpret_cast<long*>(&state_),
-                               new_state,
-                               state_);
+
+  DCHECK(sizeof(State) == sizeof(long));
+  ::InterlockedExchange(reinterpret_cast<volatile long*>(&state_),
+                        new_state);
   DCHECK_EQ(state_, new_state);
 }
 
 void DXVAVideoDecodeAccelerator::StartDecoderThread() {
   decoder_thread_.init_com_with_mta(false);
   decoder_thread_.Start();
   decoder_thread_task_runner_ = decoder_thread_.task_runner();
 }
 
 bool DXVAVideoDecodeAccelerator::OutputSamplesPresent() {
@@ skipping 124 matching lines @@
     FROM_HERE,
     base::Bind(&DXVAVideoDecodeAccelerator::CopySurfaceComplete,
                weak_this_factory_.GetWeakPtr(),
                src_surface,
                dest_surface,
                picture_buffer_id,
                input_buffer_id));
 }
 
 }  // namespace content