Replaces instances of the deprecated TimeTicks::HighResNow() with TimeTicks::Now().

gpu/command_buffer/service/program_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/program_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 535 matching lines @@
     std::string info_log = "Name conflicts between an uniform and an "
                            "attribute: " + conflicting_name;
     set_log_info(ProcessLogInfo(info_log).c_str());
     return false;
   }
   if (!CheckVaryingsPacking(varyings_packing_option)) {
     set_log_info("Varyings over maximum register limit");
     return false;
   }
 
-  TimeTicks before_time = TimeTicks::HighResNow();
+  TimeTicks before_time = TimeTicks::Now();
   bool link = true;
   ProgramCache* cache = manager_->program_cache_;
   if (cache) {
     DCHECK(!attached_shaders_[0]->signature_source().empty() &&
            !attached_shaders_[1]->signature_source().empty());
     ProgramCache::LinkedProgramStatus status = cache->GetLinkedProgramStatus(
         attached_shaders_[0]->signature_source(),
         vertex_translator,
         attached_shaders_[1]->signature_source(),
         fragment_translator,
         &bind_attrib_location_map_);
 
     if (status == ProgramCache::LINK_SUCCEEDED) {
       ProgramCache::ProgramLoadResult success =
           cache->LoadLinkedProgram(service_id(),
                                    attached_shaders_[0].get(),
                                    vertex_translator,
                                    attached_shaders_[1].get(),
                                    fragment_translator,
                                    &bind_attrib_location_map_,
                                    shader_callback);
       link = success != ProgramCache::PROGRAM_LOAD_SUCCESS;
       UMA_HISTOGRAM_BOOLEAN("GPU.ProgramCache.LoadBinarySuccess", !link);
     }
   }
 
   if (link) {
     ExecuteBindAttribLocationCalls();
-    before_time = TimeTicks::HighResNow();
+    before_time = TimeTicks::Now();
     if (cache && gfx::g_driver_gl.ext.b_GL_ARB_get_program_binary) {
       glProgramParameteri(service_id(),
                           PROGRAM_BINARY_RETRIEVABLE_HINT,
                           GL_TRUE);
     }
     glLinkProgram(service_id());
   }
 
   GLint success = 0;
   glGetProgramiv(service_id(), GL_LINK_STATUS, &success);
   if (success == GL_TRUE) {
     Update();
     if (link) {
       if (cache) {
         cache->SaveLinkedProgram(service_id(),
                                  attached_shaders_[0].get(),
                                  vertex_translator,
                                  attached_shaders_[1].get(),
                                  fragment_translator,
                                  &bind_attrib_location_map_,
                                  shader_callback);
       }
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "GPU.ProgramCache.BinaryCacheMissTime",
           static_cast<base::HistogramBase::Sample>(
-              (TimeTicks::HighResNow() - before_time).InMicroseconds()),
+              (TimeTicks::Now() - before_time).InMicroseconds()),
           0,
           static_cast<base::HistogramBase::Sample>(
               TimeDelta::FromSeconds(10).InMicroseconds()),
           50);
     } else {
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "GPU.ProgramCache.BinaryCacheHitTime",
           static_cast<base::HistogramBase::Sample>(
-              (TimeTicks::HighResNow() - before_time).InMicroseconds()),
+              (TimeTicks::Now() - before_time).InMicroseconds()),
           0,
           static_cast<base::HistogramBase::Sample>(
               TimeDelta::FromSeconds(1).InMicroseconds()),
           50);
     }
   } else {
     UpdateLogInfo();
   }
   return success == GL_TRUE;
 }
@@ skipping 784 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu