ash/wm/video_detector.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/wm/video_detector.h"
   6
   7 #include "ash/shell.h"
   8 #include "ash/wm/window_util.h"
   9 #include "ui/aura/env.h"
  10 #include "ui/aura/root_window.h"
  11 #include "ui/aura/window.h"
  12 #include "ui/gfx/rect.h"
  13
  14 namespace ash {
  15
  16 const int VideoDetector::kMinUpdateWidth = 333;
  17 const int VideoDetector::kMinUpdateHeight = 250;
  18 const int VideoDetector::kMinFramesPerSecond = 15;
  19 const double VideoDetector::kNotifyIntervalSec = 1.0;
  20
  21 // Stores information about updates to a window and determines whether it's
  22 // likely that a video is playing in it.
  23 class VideoDetector::WindowInfo {
  24  public:
  25   WindowInfo() : buffer_start_(0), buffer_size_(0) {}
  26
  27   // Handles an update within a window, returning true if it appears that
  28   // video is currently playing in the window.
  29   bool RecordUpdateAndCheckForVideo(const gfx::Rect& region,
  30                                     base::TimeTicks now) {
  31     if (region.width() < kMinUpdateWidth || region.height() < kMinUpdateHeight)
  32       return false;
  33
  34     // If the buffer is full, drop the first timestamp.
  35     if (buffer_size_ == static_cast<size_t>(kMinFramesPerSecond)) {
  36       buffer_start_ = (buffer_start_ + 1) % kMinFramesPerSecond;
  37       buffer_size_--;
  38     }
  39
  40     update_times_[(buffer_start_ + buffer_size_) % kMinFramesPerSecond] = now;
  41     buffer_size_++;
  42
  43     return buffer_size_ == static_cast<size_t>(kMinFramesPerSecond) &&
  44         (now - update_times_[buffer_start_]).InSecondsF() <= 1.0;
  45   }
  46
  47  private:
  48   // Circular buffer containing update times of the last (up to
  49   // |kMinFramesPerSecond|) video-sized updates to this window.
  50   base::TimeTicks update_times_[kMinFramesPerSecond];
  51
  52   // Index into |update_times_| of the oldest update.
  53   size_t buffer_start_;
  54
  55   // Number of updates stored in |update_times_|.
  56   size_t buffer_size_;
  57
  58   DISALLOW_COPY_AND_ASSIGN(WindowInfo);
  59 };
  60
  61 VideoDetector::VideoDetector()
  62     : observer_manager_(this),
  63       is_shutting_down_(false) {
  64   aura::Env::GetInstance()->AddObserver(this);
  65   Shell::GetInstance()->AddShellObserver(this);
  66 }
  67
  68 VideoDetector::~VideoDetector() {
  69   Shell::GetInstance()->RemoveShellObserver(this);
  70   aura::Env::GetInstance()->RemoveObserver(this);
  71 }
  72
  73 void VideoDetector::AddObserver(VideoDetectorObserver* observer) {
  74   observers_.AddObserver(observer);
  75 }
  76
  77 void VideoDetector::RemoveObserver(VideoDetectorObserver* observer) {
  78   observers_.RemoveObserver(observer);
  79 }
  80
  81 void VideoDetector::OnWindowInitialized(aura::Window* window) {
  82   observer_manager_.Add(window);
  83 }
  84
  85 void VideoDetector::OnWindowPaintScheduled(aura::Window* window,
  86                                            const gfx::Rect& region) {
  87   if (is_shutting_down_)
  88     return;
  89   linked_ptr<WindowInfo>& info = window_infos_[window];
  90   if (!info.get())
  91     info.reset(new WindowInfo);
  92
  93   base::TimeTicks now =
  94       !now_for_test_.is_null() ? now_for_test_ : base::TimeTicks::Now();
  95   if (info->RecordUpdateAndCheckForVideo(region, now))
  96     MaybeNotifyObservers(window, now);
  97 }
  98
  99 void VideoDetector::OnWindowDestroyed(aura::Window* window) {
 100   window_infos_.erase(window);
 101   observer_manager_.Remove(window);
 102 }
 103
 104 void VideoDetector::OnAppTerminating() {
 105   // Stop checking video activity once the shutdown
 106   // process starts. crbug.com/231696.
 107   is_shutting_down_ = true;
 108 }
 109
 110 void VideoDetector::MaybeNotifyObservers(aura::Window* window,
 111                                          base::TimeTicks now) {
 112   if (!last_observer_notification_time_.is_null() &&
 113       (now - last_observer_notification_time_).InSecondsF() <
 114       kNotifyIntervalSec)
 115     return;
 116
 117   if (!window->IsVisible())
 118     return;
 119
 120   gfx::Rect root_bounds = window->GetRootWindow()->bounds();
 121   if (!window->GetBoundsInRootWindow().Intersects(root_bounds))
 122     return;
 123
 124   aura::Window* toplevel_window = wm::GetActivatableWindow(window);
 125   bool is_fullscreen =
 126       toplevel_window ? wm::IsWindowFullscreen(toplevel_window) : false;
 127
 128   FOR_EACH_OBSERVER(VideoDetectorObserver,
 129                     observers_,
 130                     OnVideoDetected(is_fullscreen));
 131   last_observer_notification_time_ = now;
 132 }
 133
 134 }  // namespace ash