Revert "[scheduler] Teach scheduler about audio state"

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.h

 // 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.
 
 #ifndef THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_
 
 #include "base/atomicops.h"
 #include "base/macros.h"
 #include "base/synchronization/lock.h"
@@ skipping 137 matching lines @@
 
   void AddWebViewScheduler(WebViewSchedulerImpl* web_view_scheduler);
   void RemoveWebViewScheduler(WebViewSchedulerImpl* web_view_scheduler);
 
   void AddTaskTimeObserver(TaskTimeObserver* task_time_observer);
   void RemoveTaskTimeObserver(TaskTimeObserver* task_time_observer);
 
   // Snapshots this RendererScheduler for tracing.
   void CreateTraceEventObjectSnapshot() const;
 
-  // Called when one of associated WebView schedulers has changed audio
-  // state.
-  void OnAudioStateChanged();
-
   // Test helpers.
   SchedulerHelper* GetSchedulerHelperForTesting();
   TaskCostEstimator* GetLoadingTaskCostEstimatorForTesting();
   TaskCostEstimator* GetTimerTaskCostEstimatorForTesting();
   IdleTimeEstimator* GetIdleTimeEstimatorForTesting();
   base::TimeTicks CurrentIdleTaskDeadlineForTesting() const;
   void RunIdleTasksForTesting(const base::Closure& callback);
   void EndIdlePeriodForTesting(const base::Closure& callback,
                                base::TimeTicks time_remaining);
   bool PolicyNeedsUpdateForTesting();
 
   base::TickClock* tick_clock() const;
 
   RealTimeDomain* real_time_domain() const {
     return helper_.real_time_domain();
   }
 
   AutoAdvancingVirtualTimeDomain* GetVirtualTimeDomain();
 
-  TimeDomain* GetActiveTimeDomain();
-
   TaskQueueThrottler* task_queue_throttler() const {
     return task_queue_throttler_.get();
   }
 
  private:
   friend class RendererSchedulerImplTest;
   friend class RendererSchedulerImplForTest;
   friend class RenderWidgetSchedulingState;
 
   enum class ExpensiveTaskPolicy { RUN, BLOCK, THROTTLE };
@@ skipping 19 matching lines @@
              time_domain_type == other.time_domain_type;
     }
   };
 
   struct Policy {
     TaskQueuePolicy compositor_queue_policy;
     TaskQueuePolicy loading_queue_policy;
     TaskQueuePolicy timer_queue_policy;
     TaskQueuePolicy default_queue_policy;
     v8::RAILMode rail_mode = v8::PERFORMANCE_ANIMATION;
-    bool should_disable_throttling = false;
 
     bool operator==(const Policy& other) const {
       return compositor_queue_policy == other.compositor_queue_policy &&
              loading_queue_policy == other.loading_queue_policy &&
              timer_queue_policy == other.timer_queue_policy &&
              default_queue_policy == other.default_queue_policy &&
-             rail_mode == other.rail_mode &&
-             should_disable_throttling == other.should_disable_throttling;
+             rail_mode == other.rail_mode;
     }
   };
 
   class PollableNeedsUpdateFlag {
    public:
     PollableNeedsUpdateFlag(base::Lock* write_lock);
     ~PollableNeedsUpdateFlag();
 
     // Set the flag. May only be called if |write_lock| is held.
     void SetWhileLocked(bool value);
@@ skipping 103 matching lines @@
   // Report an intervention to all WebViews in this process.
   void BroadcastIntervention(const std::string& message);
 
   void ApplyTaskQueuePolicy(TaskQueue* task_queue,
                             const TaskQueuePolicy& old_task_queue_policy,
                             const TaskQueuePolicy& new_task_queue_policy) const;
 
   static const char* ExpensiveTaskPolicyToString(
       ExpensiveTaskPolicy expensive_task_policy);
 
-  bool ShouldDisableThrottlingBecauseOfAudio(base::TimeTicks now);
-
   SchedulerHelper helper_;
   IdleHelper idle_helper_;
   std::unique_ptr<TaskQueueThrottler> task_queue_throttler_;
   RenderWidgetSignals render_widget_scheduler_signals_;
 
   const scoped_refptr<TaskQueue> control_task_runner_;
   const scoped_refptr<TaskQueue> compositor_task_runner_;
   std::set<scoped_refptr<TaskQueue>> loading_task_runners_;
   std::set<scoped_refptr<TaskQueue>> timer_task_runners_;
   std::set<scoped_refptr<TaskQueue>> unthrottled_task_runners_;
@@ skipping 23 matching lines @@
     QueueingTimeEstimator queueing_time_estimator;
     IdleTimeEstimator idle_time_estimator;
     ThreadLoadTracker background_main_thread_load_tracker;
     ThreadLoadTracker foreground_main_thread_load_tracker;
     UseCase current_use_case;
     Policy current_policy;
     base::TimeTicks current_policy_expiration_time;
     base::TimeTicks estimated_next_frame_begin;
     base::TimeDelta compositor_frame_interval;
     base::TimeDelta longest_jank_free_task_duration;
-    base::Optional<base::TimeTicks> last_audio_state_change;
     int timer_queue_suspend_count;  // TIMER_TASK_QUEUE suspended if non-zero.
     int navigation_task_expected_count;
     ExpensiveTaskPolicy expensive_task_policy;
     bool renderer_hidden;
     bool renderer_backgrounded;
     bool renderer_suspended;
     bool timer_queue_suspension_when_backgrounded_enabled;
     bool timer_queue_suspended_when_backgrounded;
     bool was_shutdown;
     bool loading_tasks_seem_expensive;
     bool timer_tasks_seem_expensive;
     bool touchstart_expected_soon;
     bool have_seen_a_begin_main_frame;
     bool have_reported_blocking_intervention_in_current_policy;
     bool have_reported_blocking_intervention_since_navigation;
     bool has_visible_render_widget_with_touch_handler;
     bool begin_frame_not_expected_soon;
     bool in_idle_period_for_testing;
     bool use_virtual_time;
-    bool is_audio_playing;
     std::set<WebViewSchedulerImpl*> web_view_schedulers;  // Not owned.
     RAILModeObserver* rail_mode_observer;                 // Not owned.
   };
 
   struct AnyThread {
     AnyThread();
     ~AnyThread();
 
     base::TimeTicks last_idle_period_end_time;
     base::TimeTicks rails_loading_priority_deadline;
@@ skipping 58 matching lines @@
   PollableThreadSafeFlag policy_may_need_update_;
   base::WeakPtrFactory<RendererSchedulerImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImpl);
 };
 
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_