cast: Support for low-latency interactive mode

content/browser/media/capture/cursor_renderer_aura.cc

 // Copyright (c) 2015 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 "content/browser/media/capture/cursor_renderer_aura.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/time/default_tick_clock.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/cursor/cursors_aura.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/events/event_utils.h"
 #include "ui/wm/public/activation_client.h"
 
 namespace content {
 
 namespace {
 
+// The time period within which a triggered UI event is considered
+// currently active.
+const int kTimePeriodUiEventMicros = 100000;  // 100 ms
+
 inline int clip_byte(int x) {
   return std::max(0, std::min(x, 255));
 }
 
 inline int alpha_blend(int alpha, int src, int dst) {
   return (src * alpha + dst * (255 - alpha)) / 255;
 }
 
 }  // namespace
 
@@ skipping 10 matching lines @@
   if (window_) {
     window_->RemoveObserver(this);
     window_->RemovePreTargetHandler(this);
   }
 }
 
 base::WeakPtr<CursorRenderer> CursorRendererAura::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
+bool CursorRendererAura::ui_event_detected() const {
+  return (tick_clock_->NowTicks() - last_time_ui_event_detected_) <
+         base::TimeDelta::FromMicroseconds(kTimePeriodUiEventMicros);
+}
+
 void CursorRendererAura::Clear() {
   last_cursor_ = ui::Cursor();
   window_size_when_cursor_last_updated_ = gfx::Size();
   scaled_cursor_bitmap_.reset();
   last_mouse_position_x_ = 0;
   last_mouse_position_y_ = 0;
   cursor_displayed_ = false;
 }
 
 bool CursorRendererAura::SnapshotCursorState(const gfx::Rect& region_in_frame) {
@@ skipping 111 matching lines @@
         int color_v = clip_byte(
             ((color_r * 112 + color_g * -94 + color_b * -18 + 128) >> 8) + 128);
         uplane[x / 2] = alpha_blend(alpha, color_u, uplane[x / 2]);
         vplane[x / 2] = alpha_blend(alpha, color_v, vplane[x / 2]);
       }
     }
   }
   scaled_cursor_bitmap_.unlockPixels();
 }
 
+void CursorRendererAura::OnEvent(ui::Event* event) {
+  last_time_ui_event_detected_ = tick_clock_->NowTicks();
+  ui::EventHandler::OnEvent(event);
+}
+
 void CursorRendererAura::OnMouseEvent(ui::MouseEvent* event) {
   switch (event->type()) {
     case ui::ET_MOUSE_MOVED:
       if (!cursor_displayed_) {
         if (std::abs(event->x() - last_mouse_position_x_) >
                 MIN_MOVEMENT_PIXELS ||
             std::abs(event->y() - last_mouse_position_y_) > MIN_MOVEMENT_PIXELS)
           cursor_displayed_ = true;
       }
       if (cursor_displayed_) {
         last_mouse_movement_timestamp_ = event->time_stamp();
         last_mouse_position_x_ = event->x();
         last_mouse_position_y_ = event->y();
       }
       break;
     default:
       break;
   }
 }
 
 void CursorRendererAura::OnWindowDestroying(aura::Window* window) {
   DCHECK_EQ(window_, window);
   window_->RemovePreTargetHandler(this);
   window_->RemoveObserver(this);
   window_ = nullptr;
 }
 
 }  // namespace content