Take a screenshot in maximize mode when volume down and power are pressed.

ash/wm/maximize_mode/maximize_mode_event_blocker.cc

 // 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.
 
 #include "ash/wm/maximize_mode/maximize_mode_event_blocker.h"
 
+#include "ash/accelerators/accelerator_controller.h"
+#include "ash/screenshot_delegate.h"
 #include "ash/shell.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/events/event_targeter.h"
 
 namespace ash {
 
 namespace {
 
 // Event targeter to prevent delivery of mouse and touchpad events while
 // maximize mode is active. Other events such as touch are passed on to the
-// default targeter.
+// default targeter. Also handles a volume down + power key press to take a
+// screenshot while instantiated.
 // TODO(flackr): This should only stop events from the internal keyboard and
 // touchpad.
 class BlockKeyboardAndTouchpadTargeter : public ui::EventTargeter {
  public:
   BlockKeyboardAndTouchpadTargeter();
   virtual ~BlockKeyboardAndTouchpadTargeter();
 
   // Sets the default targeter to use when the event is not being blocked.
   void SetDefaultTargeter(EventTargeter* default_targeter);
 
   // Overridden from ui::EventTargeter:
   virtual ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
                                               ui::Event* event) OVERRIDE;
 
  private:
   // A weak pointer to the targeter this targeter is wrapping. The
   // default_targeter is owned by the ScopedWindowTargeter which will be valid
   // as long as this targeter is alive.
   ui::EventTargeter* default_targeter_;
 
+  // True when the volume down key is currently pressed.
+  bool volume_down_pressed_;
+
   DISALLOW_COPY_AND_ASSIGN(BlockKeyboardAndTouchpadTargeter);
 };
 
 BlockKeyboardAndTouchpadTargeter::BlockKeyboardAndTouchpadTargeter()
-    : default_targeter_(NULL) {
+    : default_targeter_(NULL),
+      volume_down_pressed_(false) {
 }
 
 BlockKeyboardAndTouchpadTargeter::~BlockKeyboardAndTouchpadTargeter() {
 }
 
 void BlockKeyboardAndTouchpadTargeter::SetDefaultTargeter(
     ui::EventTargeter* default_targeter) {
   default_targeter_ = default_targeter;
 }
 
 ui::EventTarget* BlockKeyboardAndTouchpadTargeter::FindTargetForEvent(
     ui::EventTarget* root,
     ui::Event* event) {
-  if (event->HasNativeEvent() && (event->IsMouseEvent() || event->IsKeyEvent()))
+  if (event->HasNativeEvent() && (event->IsMouseEvent() ||
+                                  event->IsKeyEvent())) {
+#if defined(OS_CHROMEOS)
+    if (event->IsKeyEvent()) {
+      ui::KeyEvent* key_event = static_cast<ui::KeyEvent*>(event);
+      if (key_event->key_code() == ui::VKEY_VOLUME_DOWN) {
+        volume_down_pressed_ = key_event->type() == ui::ET_KEY_PRESSED;
+      } else if (volume_down_pressed_ &&
+                 key_event->key_code() == ui::VKEY_POWER &&
+                 key_event->type() == ui::ET_KEY_PRESSED) {
+        ScreenshotDelegate* screenshot_delegate = Shell::GetInstance()->
+            accelerator_controller()->screenshot_delegate();
+        if (screenshot_delegate && screenshot_delegate->CanTakeScreenshot())
+          screenshot_delegate->HandleTakeScreenshotForAllRootWindows();

[sadrul, 2014/05/02 00:59:08]

I suspect this will need to be merged with bruthig@s CL.

A better way of doing this would be to do
accelerator_controller()->PerformAction()

I am not a huge fan of doing things other than targeting from a targeter. Is
this something we could do in the accelerator-controller instead? We have
accelerators that are allowed only in app mode, or not allowed in login/lock
screen. Perhaps we could have accelerators that are allowed only in
maximize-mode? Or have a MaximizeModeKeyHandler event-handler that does this
instead of doing it from here?

[flackr, 2014/05/07 04:08:44]

Now it's just dependent on it, though I suspect also needs to have the POWER key
not retargeted.
Done.
The only multi-key accelerator handling we have is for specific modifier keys,
Ctrl, Alt, etc.
https://code.google.com/p/chromium/codesearch#chromium/src/ui/events/event_co....
If I did that would I add volume down as a modifier to support adding it to
accelerator_table or add special key handling for this accelerator?

Given that potential complexity, I prefer doing this as a maximize mode event
handler, which also keeps the handling local. Done.

+      }
+    }
+#endif
     return NULL;
+  }
   return default_targeter_->FindTargetForEvent(root, event);
 }
 
 }  // namespace
 
 MaximizeModeEventBlocker::MaximizeModeEventBlocker() {
   Shell::GetInstance()->AddShellObserver(this);
 
   // Hide the cursor as mouse events will be blocked.
   aura::client::CursorClient* cursor_client_ =
@@ skipping 22 matching lines @@
     aura::Window* root_window) {
   BlockKeyboardAndTouchpadTargeter* targeter =
       new BlockKeyboardAndTouchpadTargeter();
   aura::ScopedWindowTargeter* scoped_targeter = new aura::ScopedWindowTargeter(
       root_window, scoped_ptr<ui::EventTargeter>(targeter));
   targeter->SetDefaultTargeter(scoped_targeter->old_targeter());
   targeters_.push_back(scoped_targeter);
 }
 
 }  // namespace ash