Use TimeTicks instead of clock() in gpu::CommandBufferHelper

gpu/command_buffer/client/cmd_buffer_helper.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.
 
 // This file contains the implementation of the command buffer helper class.
 
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 
 #include "base/logging.h"
+#include "base/time/time.h"

[hamaji, 2014/07/09 06:03:15]

I guessed using TimeTicks in this file is fine because we already include
base/logging.h. Correct me if I'm wrong.

 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/command_buffer/common/trace_event.h"
 
 namespace gpu {
 
 CommandBufferHelper::CommandBufferHelper(CommandBuffer* command_buffer)
     : command_buffer_(command_buffer),
       ring_buffer_id_(-1),
       ring_buffer_size_(0),
       entries_(NULL),
@@ skipping 124 matching lines @@
   command_buffer_->WaitForGetOffsetInRange(start, end);
   return command_buffer_->GetLastError() == gpu::error::kNoError;
 }
 
 void CommandBufferHelper::Flush() {
   // Wrap put_ before flush.
   if (put_ == total_entry_count_)
     put_ = 0;
 
   if (usable() && last_put_sent_ != put_) {
-    last_flush_time_ = clock();
+    last_flush_time_ = base::TimeTicks::Now().ToInternalValue();
     last_put_sent_ = put_;
     command_buffer_->Flush(put_);
     ++flush_generation_;
     CalcImmediateEntries(0);
   }
 }
 
 #if defined(CMD_HELPER_PERIODIC_FLUSH_CHECK)
 void CommandBufferHelper::PeriodicFlushCheck() {
-  clock_t current_time = clock();
-  if (current_time - last_flush_time_ > kPeriodicFlushDelay * CLOCKS_PER_SEC)
+  base::TimeTicks current_time = base::TimeTicks::Now();
+  if (current_time - base::TimeTicks::FromInternalValue(last_flush_time_) >
+      base::TimeDelta::FromSecondsD(kPeriodicFlushDelay)) {

[vmiura, 2014/07/09 20:18:58]

Could we change this to FromMicroseconds to avoid doubles -> fixed conversions?.

[hamaji, 2014/07/10 07:00:16]

Did you worry about that 1.0/300 will be converted to 0? If so, it won't happen
as I was using FromSeconds*D*. Actually, the assembly code had 0xd05, which is
3333 = 1000*1000/300. The compiler eliminated the use of float completely.

That said, there would be no reason to keep the float value. I have updated the
patch.

[vmiura, 2014/07/10 22:21:25]

Ok, it was just a performance question.  In some targets inlining might be
different, e.g. Android compiled with -Os and ARM has bad float & double support
(although this code is currently disabled on Android but on for CrOS).

Thanks for changing.

     Flush();
+  }
 }
 #endif
 
 // Calls Flush() and then waits until the buffer is empty. Break early if the
 // error is set.
 bool CommandBufferHelper::Finish() {
   TRACE_EVENT0("gpu", "CommandBufferHelper::Finish");
   if (!usable()) {
     return false;
   }
@@ skipping 105 matching lines @@
       if (!WaitForGetOffsetInRange(put_ + count + 1, put_))
         return;
       CalcImmediateEntries(count);
       DCHECK_GE(immediate_entry_count_, count);
     }
   }
 }
 
 
 }  // namespace gpu