Added more strict checks for fence sync counters.

gpu/ipc/client/command_buffer_proxy_impl.h

 // 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.
 
 #ifndef GPU_IPC_CLIENT_COMMAND_BUFFER_PROXY_IMPL_H_
 #define GPU_IPC_CLIENT_COMMAND_BUFFER_PROXY_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <queue>
 #include <string>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
+#include "base/threading/thread_checker.h"
 #include "gpu/command_buffer/client/gpu_control.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/command_buffer/common/command_buffer_id.h"
 #include "gpu/command_buffer/common/command_buffer_shared.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "gpu/gpu_export.h"
 #include "ipc/ipc_listener.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/swap_result.h"
 
@@ skipping 116 matching lines @@
   base::SharedMemoryHandle GetSharedStateHandle() const {
     return shared_state_shm_->handle();
   }
   uint32_t CreateStreamTexture(uint32_t texture_id);
 
  private:
   typedef std::map<int32_t, scoped_refptr<gpu::Buffer>> TransferBufferMap;
   typedef base::hash_map<uint32_t, base::Closure> SignalTaskMap;
 
   void CheckLock() {
-    if (lock_)
+    if (lock_) {
       lock_->AssertAcquired();
+    } else {
+      DCHECK(lockless_thread_checker_.CalledOnValidThread());
+    }
   }
 
   // Send an IPC message over the GPU channel. This is private to fully
   // encapsulate the channel; all callers of this function must explicitly
   // verify that the context has not been lost.
   bool Send(IPC::Message* msg);
 
   // Message handlers:
   void OnUpdateState(const gpu::CommandBuffer::State& state);
   void OnDestroyed(gpu::error::ContextLostReason reason,
@@ skipping 17 matching lines @@
 
   // Loses the context after we received an invalid reply from the GPU
   // process. Will post a task to call the lost context callback if any.
   void InvalidGpuReply();
 
   void InvalidGpuReplyOnClientThread();
 
   // The shared memory area used to update state.
   gpu::CommandBufferSharedState* shared_state() const;
 
+  // There should be a lock_ if this is going to be used across multiple
+  // threads, or we guarantee it is used by a single thread by using a thread
+  // checker if no lock_ is set.
   base::Lock* lock_;
+  base::ThreadChecker lockless_thread_checker_;
 
   // Client that wants to listen for important events on the GpuControl.
   gpu::GpuControlClient* gpu_control_client_;
 
   // Unowned list of DeletionObservers.
   base::ObserverList<DeletionObserver> deletion_observers_;
 
   // The last cached state received from the service.
   State last_state_;
 
@@ skipping 37 matching lines @@
 
   base::WeakPtr<CommandBufferProxyImpl> weak_this_;
   scoped_refptr<base::SequencedTaskRunner> callback_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(CommandBufferProxyImpl);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_IPC_CLIENT_COMMAND_BUFFER_PROXY_IMPL_H_