Revert 206020 "cc: Emulate BeginFrame in OutputSurfaces that don..."

trunk/src/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/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 
 namespace cc {
 
 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
     : settings_(settings),
       commit_state_(COMMIT_STATE_IDLE),
-      commit_count_(0),
       current_frame_number_(0),
       last_frame_number_where_draw_was_called_(-1),
       last_frame_number_where_tree_activation_attempted_(-1),
       last_frame_number_where_check_for_completed_tile_uploads_called_(-1),
       consecutive_failed_draws_(0),
       maximum_number_of_failed_draws_before_draw_is_forced_(3),
       needs_redraw_(false),
       swap_used_incomplete_tile_(false),
       needs_forced_redraw_(false),
       needs_forced_redraw_after_next_commit_(false),
@@ skipping 10 matching lines @@
       texture_state_(LAYER_TEXTURE_STATE_UNLOCKED),
       output_surface_state_(OUTPUT_SURFACE_LOST),
       did_create_and_initialize_first_output_surface_(false) {}
 
 std::string SchedulerStateMachine::ToString() {
   std::string str;
   base::StringAppendF(&str,
                       "settings_.impl_side_painting = %d; ",
                       settings_.impl_side_painting);
   base::StringAppendF(&str, "commit_state_ = %d; ", commit_state_);
-  base::StringAppendF(&str, "commit_count_ = %d; ", commit_count_);
   base::StringAppendF(
       &str, "current_frame_number_ = %d; ", current_frame_number_);
   base::StringAppendF(&str,
                       "last_frame_number_where_draw_was_called_ = %d; ",
                       last_frame_number_where_draw_was_called_);
   base::StringAppendF(
       &str,
       "last_frame_number_where_tree_activation_attempted_ = %d; ",
       last_frame_number_where_tree_activation_attempted_);
   base::StringAppendF(
@@ skipping 18 matching lines @@
   base::StringAppendF(
       &str, "needs_forced_commit_ = %d; ", needs_forced_commit_);
   base::StringAppendF(&str,
                       "expect_immediate_begin_frame_for_main_thread_ = %d; ",
                       expect_immediate_begin_frame_for_main_thread_);
   base::StringAppendF(&str,
                       "main_thread_needs_layer_textures_ = %d; ",
                       main_thread_needs_layer_textures_);
   base::StringAppendF(&str, "inside_begin_frame_ = %d; ",
       inside_begin_frame_);
-  base::StringAppendF(&str, "last_frame_time_ = %"PRId64"; ",
-      (last_frame_time_ - base::TimeTicks()).InMilliseconds());
   base::StringAppendF(&str, "visible_ = %d; ", visible_);
   base::StringAppendF(&str, "can_start_ = %d; ", can_start_);
   base::StringAppendF(&str, "can_draw_ = %d; ", can_draw_);
   base::StringAppendF(
       &str, "draw_if_possible_failed_ = %d; ", draw_if_possible_failed_);
   base::StringAppendF(&str, "has_pending_tree_ = %d; ", has_pending_tree_);
   base::StringAppendF(&str, "texture_state_ = %d; ", texture_state_);
   base::StringAppendF(
       &str, "output_surface_state_ = %d; ", output_surface_state_);
   return str;
@@ skipping 173 matching lines @@
 
     case ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD:
       DCHECK(!has_pending_tree_);
       DCHECK(visible_ || needs_forced_commit_);
       commit_state_ = COMMIT_STATE_FRAME_IN_PROGRESS;
       needs_commit_ = false;
       needs_forced_commit_ = false;
       return;
 
     case ACTION_COMMIT:
-      commit_count_++;
       if (expect_immediate_begin_frame_for_main_thread_)
         commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW;
       else
         commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
       // When impl-side painting, we draw on activation instead of on commit.
       if (!settings_.impl_side_painting)
         needs_redraw_ = true;
       if (draw_if_possible_failed_)
         last_frame_number_where_draw_was_called_ = -1;
 
@@ skipping 39 matching lines @@
   }
 }
 
 void SchedulerStateMachine::SetMainThreadNeedsLayerTextures() {
   DCHECK(!main_thread_needs_layer_textures_);
   DCHECK_NE(texture_state_, LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD);
   main_thread_needs_layer_textures_ = true;
 }
 
 bool SchedulerStateMachine::BeginFrameNeededByImplThread() const {
-  // We should proactively request a BeginFrame if a commit is pending.
-  if (needs_commit_ || needs_forced_commit_ ||
-      commit_state_ != COMMIT_STATE_IDLE)
-    return true;
-
   // If we have a pending tree, need to keep getting notifications until
   // the tree is ready to be swapped.
   if (has_pending_tree_)
     return true;
 
   // If we can't draw, don't tick until we are notified that we can draw again.
   if (!can_draw_)
     return false;
 
   if (needs_forced_redraw_)
     return true;
 
   if (visible_ && swap_used_incomplete_tile_)
     return true;
 
   return needs_redraw_ && visible_ &&
          output_surface_state_ == OUTPUT_SURFACE_ACTIVE;
 }
 
 void SchedulerStateMachine::DidEnterBeginFrame() {
   inside_begin_frame_ = true;
 }
 
-void SchedulerStateMachine::SetFrameTime(base::TimeTicks frame_time) {
-  last_frame_time_ = frame_time;
-}
-
 void SchedulerStateMachine::DidLeaveBeginFrame() {
   current_frame_number_++;
   inside_begin_frame_ = false;
 }
 
 void SchedulerStateMachine::SetVisible(bool visible) { visible_ = visible; }
 
 void SchedulerStateMachine::SetNeedsRedraw() { needs_redraw_ = true; }
 
 void SchedulerStateMachine::DidSwapUseIncompleteTile() {
@@ skipping 80 matching lines @@
 bool SchedulerStateMachine::HasInitializedOutputSurface() const {
   return output_surface_state_ == OUTPUT_SURFACE_ACTIVE;
 }
 
 void SchedulerStateMachine::SetMaximumNumberOfFailedDrawsBeforeDrawIsForced(
     int num_draws) {
   maximum_number_of_failed_draws_before_draw_is_forced_ = num_draws;
 }
 
 }  // namespace cc