cc: Replace > > with >>

cc/test/ordered_simple_task_runner.cc

 // Copyright 2014 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 "cc/test/ordered_simple_task_runner.h"
 
 #include <limits>
 #include <set>
 #include <sstream>
 #include <string>
@@ skipping 139 matching lines @@
   if (delay > base::TimeDelta())
     return delay;
   return base::TimeDelta();
 }
 
 const size_t OrderedSimpleTaskRunner::kAbsoluteMaxTasks =
     std::numeric_limits<size_t>::max();
 
 bool OrderedSimpleTaskRunner::RunTasksWhile(
     base::Callback<bool(void)> condition) {
-  std::vector<base::Callback<bool(void)> > conditions(1);
+  std::vector<base::Callback<bool(void)>> conditions(1);
   conditions[0] = condition;
   return RunTasksWhile(conditions);
 }
 
 bool OrderedSimpleTaskRunner::RunTasksWhile(
-    const std::vector<base::Callback<bool(void)> >& conditions) {
+    const std::vector<base::Callback<bool(void)>>& conditions) {
   TRACE_EVENT2("cc",
                "OrderedSimpleTaskRunner::RunPendingTasks",
                "this",
                AsValue(),
                "nested",
                inside_run_tasks_until_);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (inside_run_tasks_until_)
     return true;
 
   base::AutoReset<bool> reset_inside_run_tasks_until_(&inside_run_tasks_until_,
                                                       true);
 
   // Make a copy so we can append some extra run checks.
-  std::vector<base::Callback<bool(void)> > modifiable_conditions(conditions);
+  std::vector<base::Callback<bool(void)>> modifiable_conditions(conditions);
 
   // Provide a timeout base on number of tasks run so this doesn't loop
   // forever.
   modifiable_conditions.push_back(TaskRunCountBelow(max_tasks_));
 
   // If to advance now or not
   if (!advance_now_) {
     modifiable_conditions.push_back(NowBefore(now_src_->Now()));
   } else {
     modifiable_conditions.push_back(AdvanceNow());
   }
 
   while (pending_tasks_.size() > 0) {
     // Check if we should continue to run pending tasks.
     bool condition_success = true;
-    for (std::vector<base::Callback<bool(void)> >::iterator it =
+    for (std::vector<base::Callback<bool(void)>>::iterator it =
              modifiable_conditions.begin();
          it != modifiable_conditions.end();
          it++) {
       condition_success = it->Run();
       if (!condition_success)
         break;
     }
 
     // Conditions could modify the pending task length, so we need to recheck
     // that there are tasks to run.
@@ skipping 15 matching lines @@
   }
 
   return HasPendingTasks();
 }
 
 bool OrderedSimpleTaskRunner::RunPendingTasks() {
   return RunTasksWhile(TaskExistedInitially());
 }
 
 bool OrderedSimpleTaskRunner::RunUntilIdle() {
-  return RunTasksWhile(std::vector<base::Callback<bool(void)> >());
+  return RunTasksWhile(std::vector<base::Callback<bool(void)>>());
 }
 
 bool OrderedSimpleTaskRunner::RunUntilTime(base::TimeTicks time) {
   // If we are not auto advancing, force now forward to the time.
   if (!advance_now_ && now_src_->Now() < time)
     now_src_->SetNow(time);
 
   // Run tasks
   bool result = RunTasksWhile(NowBefore(time));
 
@@ skipping 80 matching lines @@
 
 bool OrderedSimpleTaskRunner::AdvanceNowCallback() {
   base::TimeTicks next_task_time = NextTaskTime();
   if (now_src_->Now() < next_task_time) {
     now_src_->SetNow(next_task_time);
   }
   return true;
 }
 
 }  // namespace cc