Delete gpu/command_buffer/client/atomicops.h

gpu/command_buffer/client/program_info_manager.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 "gpu/command_buffer/client/program_info_manager.h"
 
 #include <map>
 
 #include "base/compiler_specific.h"
-#include "gpu/command_buffer/client/atomicops.h"
+#include "base/synchronization/lock.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 
 namespace gpu {
 namespace gles2 {
 
 class NonCachedProgramInfoManager : public ProgramInfoManager {
  public:
   NonCachedProgramInfoManager();
   virtual ~NonCachedProgramInfoManager();
@@ skipping 193 matching lines @@
     bool link_status_;
   };
 
   Program* GetProgramInfo(GLES2Implementation* gl, GLuint program);
 
   // TODO(gman): Switch to a faster container.
   typedef std::map<GLuint, Program> ProgramInfoMap;
 
   ProgramInfoMap program_infos_;
 
-  mutable Lock lock_;
+  mutable base::Lock lock_;
 };
 
 CachedProgramInfoManager::Program::UniformInfo::UniformInfo(
     GLsizei _size, GLenum _type, const std::string& _name)
     : size(_size),
       type(_type),
       name(_name) {
   is_array = (!name.empty() && name[name.size() - 1] == ']');
   DCHECK(!(size > 1 && !is_array));
 }
@@ skipping 151 matching lines @@
   ProgramInfoMap::iterator it = program_infos_.find(program);
   if (it == program_infos_.end()) {
     return NULL;
   }
   Program* info = &it->second;
   info->Update(gl, program);
   return info;
 }
 
 void CachedProgramInfoManager::CreateInfo(GLuint program) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DeleteInfo(program);
   std::pair<ProgramInfoMap::iterator, bool> result =
       program_infos_.insert(std::make_pair(program, Program()));
 
   DCHECK(result.second);
 }
 
 void CachedProgramInfoManager::DeleteInfo(GLuint program) {
   program_infos_.erase(program);
 }
 
 bool CachedProgramInfoManager::GetProgramiv(
     GLES2Implementation* gl, GLuint program, GLenum pname, GLint* params) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   Program* info = GetProgramInfo(gl, program);
   if (!info) {
     return false;
   }
   return info->GetProgramiv(pname, params);
 }
 
 GLint CachedProgramInfoManager::GetAttribLocation(
     GLES2Implementation* gl, GLuint program, const char* name) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   Program* info = GetProgramInfo(gl, program);
   if (info) {
     return info->GetAttribLocation(name);
   }
   return gl->GetAttribLocationHelper(program, name);
 }
 
 GLint CachedProgramInfoManager::GetUniformLocation(
     GLES2Implementation* gl, GLuint program, const char* name) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   Program* info = GetProgramInfo(gl, program);
   if (info) {
     return info->GetUniformLocation(name);
   }
   return gl->GetUniformLocationHelper(program, name);
 }
 
 bool CachedProgramInfoManager::GetActiveAttrib(
     GLES2Implementation* gl,
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
     GLint* size, GLenum* type, char* name) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   Program* info = GetProgramInfo(gl, program);
   if (info) {
     const Program::VertexAttrib* attrib_info =
         info->GetAttribInfo(index);
     if (attrib_info) {
       if (size) {
         *size = attrib_info->size;
       }
       if (type) {
         *type = attrib_info->type;
@@ skipping 14 matching lines @@
     }
   }
   return gl->GetActiveAttribHelper(
       program, index, bufsize, length, size, type, name);
 }
 
 bool CachedProgramInfoManager::GetActiveUniform(
     GLES2Implementation* gl,
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
     GLint* size, GLenum* type, char* name) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   Program* info = GetProgramInfo(gl, program);
   if (info) {
     const Program::UniformInfo* uniform_info = info->GetUniformInfo(index);
     if (uniform_info) {
       if (size) {
         *size = uniform_info->size;
       }
       if (type) {
         *type = uniform_info->type;
       }
@@ skipping 27 matching lines @@
   if (shared_resources_across_processes) {
     return new NonCachedProgramInfoManager();
   } else {
     return new CachedProgramInfoManager();
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu