Switch to standard integer types in gpu/.

gpu/command_buffer/service/query_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/service/query_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/numerics/safe_math.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gpu_timing.h"
 
 namespace gpu {
 namespace gles2 {
 
 class AbstractIntegerQuery : public QueryManager::Query {
  public:
-  AbstractIntegerQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  AbstractIntegerQuery(QueryManager* manager,
+                       GLenum target,
+                       int32_t shm_id,
+                       uint32_t shm_offset);
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
   bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   void Pause() override;
   void Resume() override;
   void Destroy(bool have_context) override;
 
  protected:
   ~AbstractIntegerQuery() override;
   bool AreAllResultsAvailable();
 
   // Service side query ids.
   std::vector<GLuint> service_ids_;
 };
 
-AbstractIntegerQuery::AbstractIntegerQuery(
-    QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
+AbstractIntegerQuery::AbstractIntegerQuery(QueryManager* manager,
+                                           GLenum target,
+                                           int32_t shm_id,
+                                           uint32_t shm_offset)
     : Query(manager, target, shm_id, shm_offset) {
   GLuint service_id = 0;
   glGenQueries(1, &service_id);
   DCHECK_NE(0u, service_id);
   service_ids_.push_back(service_id);
 }
 
 bool AbstractIntegerQuery::Begin() {
   MarkAsActive();
   // Delete all but the first one when beginning a new query.
@@ skipping 43 matching lines @@
 
 bool AbstractIntegerQuery::AreAllResultsAvailable() {
   GLuint available = 0;
   glGetQueryObjectuiv(
       service_ids_.back(), GL_QUERY_RESULT_AVAILABLE_EXT, &available);
   return !!available;
 }
 
 class BooleanQuery : public AbstractIntegerQuery {
  public:
-  BooleanQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  BooleanQuery(QueryManager* manager,
+               GLenum target,
+               int32_t shm_id,
+               uint32_t shm_offset);
   bool Process(bool did_finish) override;
 
  protected:
   ~BooleanQuery() override;
 };
 
-BooleanQuery::BooleanQuery(
-    QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
-    : AbstractIntegerQuery(manager, target, shm_id, shm_offset) {
-}
+BooleanQuery::BooleanQuery(QueryManager* manager,
+                           GLenum target,
+                           int32_t shm_id,
+                           uint32_t shm_offset)
+    : AbstractIntegerQuery(manager, target, shm_id, shm_offset) {}
 
 BooleanQuery::~BooleanQuery() {
 }
 
 bool BooleanQuery::Process(bool did_finish) {
   if (!AreAllResultsAvailable()) {
     // Must return true to avoid generating an error at the command
     // buffer level.
     return true;
   }
   for (const GLuint& service_id : service_ids_) {
     GLuint result = 0;
     glGetQueryObjectuiv(service_id, GL_QUERY_RESULT_EXT, &result);
     if (result != 0)
       return MarkAsCompleted(1);
   }
   return MarkAsCompleted(0);
 }
 
 class SummedIntegerQuery : public AbstractIntegerQuery {
  public:
-  SummedIntegerQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  SummedIntegerQuery(QueryManager* manager,
+                     GLenum target,
+                     int32_t shm_id,
+                     uint32_t shm_offset);
   bool Process(bool did_finish) override;
 
  protected:
   ~SummedIntegerQuery() override;
 };
 
-SummedIntegerQuery::SummedIntegerQuery(
-    QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
-    : AbstractIntegerQuery(manager, target, shm_id, shm_offset) {
-}
+SummedIntegerQuery::SummedIntegerQuery(QueryManager* manager,
+                                       GLenum target,
+                                       int32_t shm_id,
+                                       uint32_t shm_offset)
+    : AbstractIntegerQuery(manager, target, shm_id, shm_offset) {}
 
 SummedIntegerQuery::~SummedIntegerQuery() {
 }
 
 bool SummedIntegerQuery::Process(bool did_finish) {
   if (!AreAllResultsAvailable()) {
     // Must return true to avoid generating an error at the command
     // buffer level.
     return true;
   }
   GLuint summed_result = 0;
   for (const GLuint& service_id : service_ids_) {
     GLuint result = 0;
     glGetQueryObjectuiv(service_id, GL_QUERY_RESULT_EXT, &result);
     summed_result += result;
   }
   return MarkAsCompleted(summed_result);
 }
 
 class CommandsIssuedQuery : public QueryManager::Query {
  public:
-  CommandsIssuedQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  CommandsIssuedQuery(QueryManager* manager,
+                      GLenum target,
+                      int32_t shm_id,
+                      uint32_t shm_offset);
 
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
   bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   void Pause() override;
   void Resume() override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~CommandsIssuedQuery() override;
 
  private:
   base::TimeTicks begin_time_;
 };
 
-CommandsIssuedQuery::CommandsIssuedQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
-    : Query(manager, target, shm_id, shm_offset) {
-}
+CommandsIssuedQuery::CommandsIssuedQuery(QueryManager* manager,
+                                         GLenum target,
+                                         int32_t shm_id,
+                                         uint32_t shm_offset)
+    : Query(manager, target, shm_id, shm_offset) {}
 
 bool CommandsIssuedQuery::Begin() {
   MarkAsActive();
   begin_time_ = base::TimeTicks::Now();
   return true;
 }
 
 void CommandsIssuedQuery::Pause() {
   MarkAsPaused();
 }
@@ skipping 22 matching lines @@
   if (!IsDeleted()) {
     MarkAsDeleted();
   }
 }
 
 CommandsIssuedQuery::~CommandsIssuedQuery() {
 }
 
 class CommandLatencyQuery : public QueryManager::Query {
  public:
-  CommandLatencyQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  CommandLatencyQuery(QueryManager* manager,
+                      GLenum target,
+                      int32_t shm_id,
+                      uint32_t shm_offset);
 
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
   bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   void Pause() override;
   void Resume() override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~CommandLatencyQuery() override;
 };
 
-CommandLatencyQuery::CommandLatencyQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
-    : Query(manager, target, shm_id, shm_offset) {
-}
+CommandLatencyQuery::CommandLatencyQuery(QueryManager* manager,
+                                         GLenum target,
+                                         int32_t shm_id,
+                                         uint32_t shm_offset)
+    : Query(manager, target, shm_id, shm_offset) {}
 
 bool CommandLatencyQuery::Begin() {
   MarkAsActive();
   return true;
 }
 
 void CommandLatencyQuery::Pause() {
   MarkAsPaused();
 }
 
@@ skipping 24 matching lines @@
 }
 
 CommandLatencyQuery::~CommandLatencyQuery() {
 }
 
 
 class AsyncReadPixelsCompletedQuery
     : public QueryManager::Query,
       public base::SupportsWeakPtr<AsyncReadPixelsCompletedQuery> {
  public:
-  AsyncReadPixelsCompletedQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  AsyncReadPixelsCompletedQuery(QueryManager* manager,
+                                GLenum target,
+                                int32_t shm_id,
+                                uint32_t shm_offset);
 
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
   bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   void Pause() override;
   void Resume() override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   void Complete();
   ~AsyncReadPixelsCompletedQuery() override;
 
  private:
   bool complete_result_;
 };
 
 AsyncReadPixelsCompletedQuery::AsyncReadPixelsCompletedQuery(
-    QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
-    : Query(manager, target, shm_id, shm_offset),
-      complete_result_(false) {
-}
+    QueryManager* manager,
+    GLenum target,
+    int32_t shm_id,
+    uint32_t shm_offset)
+    : Query(manager, target, shm_id, shm_offset), complete_result_(false) {}
 
 bool AsyncReadPixelsCompletedQuery::Begin() {
   MarkAsActive();
   return true;
 }
 
 void AsyncReadPixelsCompletedQuery::Pause() {
   MarkAsPaused();
 }
 
@@ skipping 31 matching lines @@
     MarkAsDeleted();
   }
 }
 
 AsyncReadPixelsCompletedQuery::~AsyncReadPixelsCompletedQuery() {
 }
 
 
 class GetErrorQuery : public QueryManager::Query {
  public:
-  GetErrorQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  GetErrorQuery(QueryManager* manager,
+                GLenum target,
+                int32_t shm_id,
+                uint32_t shm_offset);
 
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
   bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   void Pause() override;
   void Resume() override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~GetErrorQuery() override;
 
  private:
 };
 
-GetErrorQuery::GetErrorQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
-    : Query(manager, target, shm_id, shm_offset) {
-}
+GetErrorQuery::GetErrorQuery(QueryManager* manager,
+                             GLenum target,
+                             int32_t shm_id,
+                             uint32_t shm_offset)
+    : Query(manager, target, shm_id, shm_offset) {}
 
 bool GetErrorQuery::Begin() {
   MarkAsActive();
   return true;
 }
 
 void GetErrorQuery::Pause() {
   MarkAsPaused();
 }
 
@@ skipping 22 matching lines @@
   }
 }
 
 GetErrorQuery::~GetErrorQuery() {
 }
 
 class CommandsCompletedQuery : public QueryManager::Query {
  public:
   CommandsCompletedQuery(QueryManager* manager,
                          GLenum target,
-                         int32 shm_id,
-                         uint32 shm_offset);
+                         int32_t shm_id,
+                         uint32_t shm_offset);
 
   // Overridden from QueryManager::Query:
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
   bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   void Pause() override;
   void Resume() override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~CommandsCompletedQuery() override;
 
  private:
   scoped_ptr<gfx::GLFence> fence_;
   base::TimeTicks begin_time_;
 };
 
 CommandsCompletedQuery::CommandsCompletedQuery(QueryManager* manager,
                                                GLenum target,
-                                               int32 shm_id,
-                                               uint32 shm_offset)
+                                               int32_t shm_id,
+                                               uint32_t shm_offset)
     : Query(manager, target, shm_id, shm_offset) {}
 
 bool CommandsCompletedQuery::Begin() {
   MarkAsActive();
   begin_time_ = base::TimeTicks::Now();
   return true;
 }
 
 void CommandsCompletedQuery::Pause() {
   MarkAsPaused();
@@ skipping 31 matching lines @@
     MarkAsDeleted();
   }
 }
 
 CommandsCompletedQuery::~CommandsCompletedQuery() {}
 
 class TimeElapsedQuery : public QueryManager::Query {
  public:
   TimeElapsedQuery(QueryManager* manager,
                    GLenum target,
-                   int32 shm_id,
-                   uint32 shm_offset);
+                   int32_t shm_id,
+                   uint32_t shm_offset);
 
   // Overridden from QueryManager::Query:
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
   bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   void Pause() override;
   void Resume() override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~TimeElapsedQuery() override;
 
  private:
   scoped_ptr<gfx::GPUTimer> gpu_timer_;
 };
 
 TimeElapsedQuery::TimeElapsedQuery(QueryManager* manager,
                                    GLenum target,
-                                   int32 shm_id,
-                                   uint32 shm_offset)
+                                   int32_t shm_id,
+                                   uint32_t shm_offset)
     : Query(manager, target, shm_id, shm_offset),
-      gpu_timer_(manager->CreateGPUTimer(true)) {
-}
+      gpu_timer_(manager->CreateGPUTimer(true)) {}
 
 bool TimeElapsedQuery::Begin() {
   // Reset the disjoint value before the query begins if it is safe.
   SafelyResetDisjointValue();
   MarkAsActive();
   gpu_timer_->Start();
   return true;
 }
 
 bool TimeElapsedQuery::End(base::subtle::Atomic32 submit_count) {
@@ skipping 32 matching lines @@
 void TimeElapsedQuery::Destroy(bool have_context) {
   gpu_timer_->Destroy(have_context);
 }
 
 TimeElapsedQuery::~TimeElapsedQuery() {}
 
 class TimeStampQuery : public QueryManager::Query {
  public:
   TimeStampQuery(QueryManager* manager,
                  GLenum target,
-                 int32 shm_id,
-                 uint32 shm_offset);
+                 int32_t shm_id,
+                 uint32_t shm_offset);
 
   // Overridden from QueryManager::Query:
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
   bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   void Pause() override;
   void Resume() override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~TimeStampQuery() override;
 
  private:
   scoped_ptr<gfx::GPUTimer> gpu_timer_;
 };
 
 TimeStampQuery::TimeStampQuery(QueryManager* manager,
                                GLenum target,
-                               int32 shm_id,
-                               uint32 shm_offset)
+                               int32_t shm_id,
+                               uint32_t shm_offset)
     : Query(manager, target, shm_id, shm_offset),
       gpu_timer_(manager->CreateGPUTimer(false)) {}
 
 bool TimeStampQuery::Begin() {
   NOTREACHED();
   return false;
 }
 
 bool TimeStampQuery::End(base::subtle::Atomic32 submit_count) {
   NOTREACHED();
@@ skipping 87 matching lines @@
   pending_queries_.clear();
   pending_transfer_queries_.clear();
   active_queries_.clear();
   while (!queries_.empty()) {
     Query* query = queries_.begin()->second.get();
     query->Destroy(have_context);
     queries_.erase(queries_.begin());
   }
 }
 
-void QueryManager::SetDisjointSync(int32 shm_id, uint32 shm_offset) {
+void QueryManager::SetDisjointSync(int32_t shm_id, uint32_t shm_offset) {
   DCHECK(disjoint_notify_shm_id_ == -1);
   DCHECK(shm_id != -1);
 
   DisjointValueSync* sync = decoder_->GetSharedMemoryAs<DisjointValueSync*>(
       shm_id, shm_offset, sizeof(*sync));
   DCHECK(sync);
   sync->Reset();
   disjoints_notified_ = 0;
 
   disjoint_notify_shm_id_ = shm_id;
   disjoint_notify_shm_offset_ = shm_offset;
 }
 
-QueryManager::Query* QueryManager::CreateQuery(
-    GLenum target, GLuint client_id, int32 shm_id, uint32 shm_offset) {
+QueryManager::Query* QueryManager::CreateQuery(GLenum target,
+                                               GLuint client_id,
+                                               int32_t shm_id,
+                                               uint32_t shm_offset) {
   scoped_refptr<Query> query;
   switch (target) {
     case GL_COMMANDS_ISSUED_CHROMIUM:
       query = new CommandsIssuedQuery(this, target, shm_id, shm_offset);
       break;
     case GL_LATENCY_QUERY_CHROMIUM:
       query = new CommandLatencyQuery(this, target, shm_id, shm_offset);
       break;
     case GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM:
       query = new AsyncReadPixelsCompletedQuery(
@@ skipping 139 matching lines @@
 
 void QueryManager::SafelyResetDisjointValue() {
   // It is only safe to reset the disjoint value is there is no active
   // elapsed timer and we are not continually updating the disjoint value.
   if (!update_disjoints_continually_ && !GetActiveQuery(GL_TIME_ELAPSED)) {
     // Reset the error state without storing the result.
     gpu_timing_client_->CheckAndResetTimerErrors();
   }
 }
 
-QueryManager::Query::Query(
-     QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
+QueryManager::Query::Query(QueryManager* manager,
+                           GLenum target,
+                           int32_t shm_id,
+                           uint32_t shm_offset)
     : manager_(manager),
       target_(target),
       shm_id_(shm_id),
       shm_offset_(shm_offset),
       submit_count_(0),
       query_state_(kQueryState_Initialize),
       deleted_(false) {
   DCHECK(manager);
   manager_->StartTracking(this);
 }
@@ skipping 17 matching lines @@
   // The query is getting deleted, either by the client or
   // because the context was lost. Call any outstanding
   // callbacks to avoid leaks.
   RunCallbacks();
   if (manager_) {
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
-bool QueryManager::Query::MarkAsCompleted(uint64 result) {
+bool QueryManager::Query::MarkAsCompleted(uint64_t result) {
   UnmarkAsPending();
   QuerySync* sync = manager_->decoder_->GetSharedMemoryAs<QuerySync*>(
       shm_id_, shm_offset_, sizeof(*sync));
   if (!sync) {
     return false;
   }
 
   sync->result = result;
   base::subtle::Release_Store(&sync->process_count, submit_count_);
 
@@ skipping 146 matching lines @@
   for (std::pair<const GLenum, scoped_refptr<Query> >& it : active_queries_) {
     if (it.second->IsPaused()) {
       it.second->Resume();
       DCHECK(it.second->IsActive());
     }
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu