Added hotkey support to 8508009

ui/aura/desktop.cc

 // Copyright (c) 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 "ui/aura/desktop.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "ui/aura/aura_switches.h"
 #include "ui/aura/client/stacking_client.h"
 #include "ui/aura/desktop_host.h"
 #include "ui/aura/desktop_observer.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/screen_aura.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/gfx/compositor/compositor.h"
+#include "ui/gfx/compositor/debug_utils.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/compositor/layer_animation_sequence.h"
 #include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/compositor/screen_rotation.h"
 #include "ui/gfx/interpolated_transform.h"
 
 using std::string;
 using std::vector;
 
 namespace aura {
@@ skipping 92 matching lines @@
         ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
     scoped_ptr<ui::LayerAnimationSequence> screen_rotation(
         new ui::LayerAnimationSequence(new ui::ScreenRotation(delta)));
     screen_rotation->AddObserver(desktop);
     desktop->layer()->GetAnimator()->ScheduleAnimation(
         screen_rotation.release());
     return true;
   }
   return false;
 }
+
+bool MaybePrintDebug(Desktop* desktop, KeyEvent* event) {

[Ben Goodger (Google), 2011/11/17 21:03:17]

Can you wait until mazda lands his keyboard stuff? I don't think we should put
this in Aura. You should add it to his ShellAcceleratorController instead, where
we've moved fullscreen/rotation debug shortcuts to

+  if ((event->flags() & ui::EF_ALT_DOWN) &&
+      event->key_code() == ui::VKEY_L) {
+    ui::PrintLayerHierarchy(desktop->layer());
+    return true;
+  }
+  return false;
+}
 #endif
 
 }  // namespace
 
 Desktop* Desktop::instance_ = NULL;
 bool Desktop::use_fullscreen_host_window_ = false;
 
 Desktop::Desktop()
     : Window(NULL),
       host_(aura::DesktopHost::Create(GetInitialHostWindowBounds())),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           stacking_client_(new DefaultStackingClient(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(schedule_paint_factory_(this)),
       active_window_(NULL),
       mouse_button_flags_(0),
       last_cursor_(kCursorNull),
       in_destructor_(false),
       screen_(new ScreenAura),
       capture_window_(NULL),
       mouse_pressed_handler_(NULL),
       mouse_moved_handler_(NULL),
       focused_window_(NULL),
       touch_event_handler_(NULL) {
-  set_name("RootWindow");
+  SetName("RootWindow");
   gfx::Screen::SetInstance(screen_);
   host_->SetDesktop(this);
   last_mouse_location_ = host_->QueryMouseLocation();
 
   if (ui::Compositor::compositor_factory()) {
     compositor_ = (*ui::Compositor::compositor_factory())(this);
   } else {
     compositor_ = ui::Compositor::Create(this, host_->GetAcceleratedWidget(),
                                          host_->GetSize());
   }
@@ skipping 99 matching lines @@
   return false;
 }
 
 bool Desktop::DispatchKeyEvent(KeyEvent* event) {
 #if !defined(NDEBUG)
   // TODO(beng): replace this hack with global keyboard event handlers.
   if (event->type() == ui::ET_KEY_PRESSED) {
     if (MaybeFullScreen(host_.get(), event) || MaybeRotate(this, event))
       return true;
   }
+
+  if (event->type() == ui::ET_KEY_RELEASED && MaybePrintDebug(this, event))
+    return true;
 #endif
 
   if (focused_window_) {
     KeyEvent translated_event(*event);
     return ProcessKeyEvent(focused_window_, &translated_event);
   }
   return false;
 }
 
 bool Desktop::DispatchTouchEvent(TouchEvent* event) {
@@ skipping 313 matching lines @@
       base::StringToInt(parts[1], &parsed_height) && parsed_height > 0) {
     bounds.set_size(gfx::Size(parsed_width, parsed_height));
   } else if (use_fullscreen_host_window_) {
     bounds = gfx::Rect(DesktopHost::GetNativeDisplaySize());
   }
 
   return bounds;
 }
 
 }  // namespace aura