Revert of Add builders for tracing event's structural arguments

cc/scheduler/scheduler_state_machine.cc

 // Copyright 2011 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/scheduler/scheduler_state_machine.h"
 
 #include "base/debug/trace_event.h"
-#include "base/debug/trace_event_argument.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "ui/gfx/frame_time.h"
 
 namespace cc {
 
 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
     : settings_(settings),
@@ skipping 122 matching lines @@
       return "ACTION_DRAW_AND_SWAP_ABORT";
     case ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
       return "ACTION_BEGIN_OUTPUT_SURFACE_CREATION";
     case ACTION_MANAGE_TILES:
       return "ACTION_MANAGE_TILES";
   }
   NOTREACHED();
   return "???";
 }
 
-scoped_refptr<base::debug::ConvertableToTraceFormat>
-SchedulerStateMachine::AsValue() const {
-  scoped_refptr<base::debug::TracedValue> state =
-      new base::debug::TracedValue();
-  AsValueInto(state);
-  return state;
-}
+scoped_ptr<base::Value> SchedulerStateMachine::AsValue() const  {
+  scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue);
 
-void SchedulerStateMachine::AsValueInto(base::debug::TracedValue* state) const {
-  state->BeginDictionary("major_state");
-  state->SetString("next_action", ActionToString(NextAction()));
-  state->SetString("begin_impl_frame_state",
-                   BeginImplFrameStateToString(begin_impl_frame_state_));
-  state->SetString("commit_state", CommitStateToString(commit_state_));
-  state->SetString("output_surface_state_",
-                   OutputSurfaceStateToString(output_surface_state_));
-  state->SetString("forced_redraw_state",
-                   ForcedRedrawOnTimeoutStateToString(forced_redraw_state_));
-  state->EndDictionary();
+  scoped_ptr<base::DictionaryValue> major_state(new base::DictionaryValue);
+  major_state->SetString("next_action", ActionToString(NextAction()));
+  major_state->SetString("begin_impl_frame_state",
+                         BeginImplFrameStateToString(begin_impl_frame_state_));
+  major_state->SetString("commit_state", CommitStateToString(commit_state_));
+  major_state->SetString("output_surface_state_",
+                         OutputSurfaceStateToString(output_surface_state_));
+  major_state->SetString(
+      "forced_redraw_state",
+      ForcedRedrawOnTimeoutStateToString(forced_redraw_state_));
+  state->Set("major_state", major_state.release());
 
-  state->BeginDictionary("major_timestamps_in_ms");
+  scoped_ptr<base::DictionaryValue> timestamps_state(new base::DictionaryValue);
   base::TimeTicks now = gfx::FrameTime::Now();
-  state->SetDouble("0_interval",
-                   begin_impl_frame_args_.interval.InMicroseconds() / 1000.0L);
-  state->SetDouble(
+  timestamps_state->SetDouble(
+      "0_interval", begin_impl_frame_args_.interval.InMicroseconds() / 1000.0L);
+  timestamps_state->SetDouble(
       "1_now_to_deadline",
       (begin_impl_frame_args_.deadline - now).InMicroseconds() / 1000.0L);
-  state->SetDouble(
+  timestamps_state->SetDouble(
       "2_frame_time_to_now",
       (now - begin_impl_frame_args_.frame_time).InMicroseconds() / 1000.0L);
-  state->SetDouble("3_frame_time_to_deadline",
-                   (begin_impl_frame_args_.deadline -
-                    begin_impl_frame_args_.frame_time).InMicroseconds() /
-                       1000.0L);
-  state->SetDouble("4_now",
-                   (now - base::TimeTicks()).InMicroseconds() / 1000.0L);
-  state->SetDouble(
+  timestamps_state->SetDouble(
+      "3_frame_time_to_deadline",
+      (begin_impl_frame_args_.deadline - begin_impl_frame_args_.frame_time)
+              .InMicroseconds() /
+          1000.0L);
+  timestamps_state->SetDouble(
+      "4_now", (now - base::TimeTicks()).InMicroseconds() / 1000.0L);
+  timestamps_state->SetDouble(
       "5_frame_time",
       (begin_impl_frame_args_.frame_time - base::TimeTicks()).InMicroseconds() /
           1000.0L);
-  state->SetDouble(
+  timestamps_state->SetDouble(
       "6_deadline",
       (begin_impl_frame_args_.deadline - base::TimeTicks()).InMicroseconds() /
           1000.0L);
-  state->EndDictionary();
+  state->Set("major_timestamps_in_ms", timestamps_state.release());
 
-  state->BeginDictionary("minor_state");
-  state->SetInteger("commit_count", commit_count_);
-  state->SetInteger("current_frame_number", current_frame_number_);
+  scoped_ptr<base::DictionaryValue> minor_state(new base::DictionaryValue);
+  minor_state->SetInteger("commit_count", commit_count_);
+  minor_state->SetInteger("current_frame_number", current_frame_number_);
 
-  state->SetInteger("last_frame_number_animate_performed",
-                    last_frame_number_animate_performed_);
-  state->SetInteger("last_frame_number_swap_performed",
-                    last_frame_number_swap_performed_);
-  state->SetInteger("last_frame_number_swap_requested",
-                    last_frame_number_swap_requested_);
-  state->SetInteger("last_frame_number_begin_main_frame_sent",
-                    last_frame_number_begin_main_frame_sent_);
-  state->SetInteger("last_frame_number_update_visible_tiles_was_called",
-                    last_frame_number_update_visible_tiles_was_called_);
+  minor_state->SetInteger("last_frame_number_animate_performed",
+                          last_frame_number_animate_performed_);
+  minor_state->SetInteger("last_frame_number_swap_performed",
+                          last_frame_number_swap_performed_);
+  minor_state->SetInteger("last_frame_number_swap_requested",
+                          last_frame_number_swap_requested_);
+  minor_state->SetInteger(
+      "last_frame_number_begin_main_frame_sent",
+      last_frame_number_begin_main_frame_sent_);
+  minor_state->SetInteger(
+      "last_frame_number_update_visible_tiles_was_called",
+      last_frame_number_update_visible_tiles_was_called_);
 
-  state->SetInteger("manage_tiles_funnel", manage_tiles_funnel_);
-  state->SetInteger("consecutive_checkerboard_animations",
-                    consecutive_checkerboard_animations_);
-  state->SetInteger("max_pending_swaps_", max_pending_swaps_);
-  state->SetInteger("pending_swaps_", pending_swaps_);
-  state->SetBoolean("needs_redraw", needs_redraw_);
-  state->SetBoolean("needs_animate_", needs_animate_);
-  state->SetBoolean("needs_manage_tiles", needs_manage_tiles_);
-  state->SetBoolean("swap_used_incomplete_tile", swap_used_incomplete_tile_);
-  state->SetBoolean("needs_commit", needs_commit_);
-  state->SetBoolean("visible", visible_);
-  state->SetBoolean("can_start", can_start_);
-  state->SetBoolean("can_draw", can_draw_);
-  state->SetBoolean("has_pending_tree", has_pending_tree_);
-  state->SetBoolean("pending_tree_is_ready_for_activation",
-                    pending_tree_is_ready_for_activation_);
-  state->SetBoolean("active_tree_needs_first_draw",
-                    active_tree_needs_first_draw_);
-  state->SetBoolean("did_create_and_initialize_first_output_surface",
-                    did_create_and_initialize_first_output_surface_);
-  state->SetBoolean("smoothness_takes_priority", smoothness_takes_priority_);
-  state->SetBoolean("main_thread_is_in_high_latency_mode",
-                    MainThreadIsInHighLatencyMode());
-  state->SetBoolean("skip_begin_main_frame_to_reduce_latency",
-                    skip_begin_main_frame_to_reduce_latency_);
-  state->SetBoolean("skip_next_begin_main_frame_to_reduce_latency",
-                    skip_next_begin_main_frame_to_reduce_latency_);
-  state->SetBoolean("continuous_painting", continuous_painting_);
-  state->EndDictionary();
+  minor_state->SetInteger("manage_tiles_funnel", manage_tiles_funnel_);
+  minor_state->SetInteger("consecutive_checkerboard_animations",
+                          consecutive_checkerboard_animations_);
+  minor_state->SetInteger("max_pending_swaps_", max_pending_swaps_);
+  minor_state->SetInteger("pending_swaps_", pending_swaps_);
+  minor_state->SetBoolean("needs_redraw", needs_redraw_);
+  minor_state->SetBoolean("needs_animate_", needs_animate_);
+  minor_state->SetBoolean("needs_manage_tiles", needs_manage_tiles_);
+  minor_state->SetBoolean("swap_used_incomplete_tile",
+                          swap_used_incomplete_tile_);
+  minor_state->SetBoolean("needs_commit", needs_commit_);
+  minor_state->SetBoolean("visible", visible_);
+  minor_state->SetBoolean("can_start", can_start_);
+  minor_state->SetBoolean("can_draw", can_draw_);
+  minor_state->SetBoolean("has_pending_tree", has_pending_tree_);
+  minor_state->SetBoolean("pending_tree_is_ready_for_activation",
+                          pending_tree_is_ready_for_activation_);
+  minor_state->SetBoolean("active_tree_needs_first_draw",
+                          active_tree_needs_first_draw_);
+  minor_state->SetBoolean("did_create_and_initialize_first_output_surface",
+                          did_create_and_initialize_first_output_surface_);
+  minor_state->SetBoolean("smoothness_takes_priority",
+                          smoothness_takes_priority_);
+  minor_state->SetBoolean("main_thread_is_in_high_latency_mode",
+                          MainThreadIsInHighLatencyMode());
+  minor_state->SetBoolean("skip_begin_main_frame_to_reduce_latency",
+                          skip_begin_main_frame_to_reduce_latency_);
+  minor_state->SetBoolean("skip_next_begin_main_frame_to_reduce_latency",
+                          skip_next_begin_main_frame_to_reduce_latency_);
+  minor_state->SetBoolean("continuous_painting", continuous_painting_);
+  state->Set("minor_state", minor_state.release());
+
+  return state.PassAs<base::Value>();
 }
 
 void SchedulerStateMachine::AdvanceCurrentFrameNumber() {
   current_frame_number_++;
 
   // "Drain" the ManageTiles funnel.
   if (manage_tiles_funnel_ > 0)
     manage_tiles_funnel_--;
 
   skip_begin_main_frame_to_reduce_latency_ =
@@ skipping 551 matching lines @@
   // BeginImplFrame.
   if (HasRequestedSwapThisFrame())
     return true;
 
   return false;
 }
 
 void SchedulerStateMachine::OnBeginImplFrame(const BeginFrameArgs& args) {
   AdvanceCurrentFrameNumber();
   begin_impl_frame_args_ = args;
-  DCHECK_EQ(begin_impl_frame_state_, BEGIN_IMPL_FRAME_STATE_IDLE)
-      << AsValue()->ToString();
+  DCHECK_EQ(begin_impl_frame_state_, BEGIN_IMPL_FRAME_STATE_IDLE) << *AsValue();
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameDeadlinePending() {
   DCHECK_EQ(begin_impl_frame_state_,
             BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING)
-      << AsValue()->ToString();
+      << *AsValue();
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameDeadline() {
   DCHECK_EQ(begin_impl_frame_state_, BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME)
-      << AsValue()->ToString();
+      << *AsValue();
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameIdle() {
   DCHECK_EQ(begin_impl_frame_state_, BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)
-      << AsValue()->ToString();
+      << *AsValue();
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_IDLE;
 }
 
 bool SchedulerStateMachine::ShouldTriggerBeginImplFrameDeadlineEarly() const {
   // TODO(brianderson): This should take into account multiple commit sources.
 
   if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME)
     return false;
 
   // If we've lost the output surface, end the current BeginImplFrame ASAP
@@ skipping 159 matching lines @@
       // removing textures (which might not).  To be safe, request a commit
       // anyway.
       needs_commit_ = true;
       break;
   }
 }
 
 void SchedulerStateMachine::SetNeedsCommit() { needs_commit_ = true; }
 
 void SchedulerStateMachine::NotifyReadyToCommit() {
-  DCHECK(commit_state_ == COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED)
-      << AsValue()->ToString();
+  DCHECK(commit_state_ == COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED) << *AsValue();
   commit_state_ = COMMIT_STATE_READY_TO_COMMIT;
 }
 
 void SchedulerStateMachine::BeginMainFrameAborted(bool did_handle) {
   DCHECK_EQ(commit_state_, COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
   if (did_handle) {
     bool commit_was_aborted = true;
     UpdateStateOnCommit(commit_was_aborted);
   } else {
     commit_state_ = COMMIT_STATE_IDLE;
@@ skipping 47 matching lines @@
     case OUTPUT_SURFACE_ACTIVE:
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT:
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION:
       return true;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace cc