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

ash/wm/maximize_mode/maximize_mode_event_blocker.cc

Index: ash/wm/maximize_mode/maximize_mode_event_blocker.cc
diff --git a/ash/wm/maximize_mode/maximize_mode_event_blocker.cc b/ash/wm/maximize_mode/maximize_mode_event_blocker.cc
index e283149b6fe66755d368efea094e209f45419b0c..511b085c1b006e6491159c914428acde924e0af3 100644
--- a/ash/wm/maximize_mode/maximize_mode_event_blocker.cc
+++ b/ash/wm/maximize_mode/maximize_mode_event_blocker.cc
@@ -4,6 +4,8 @@
 
 #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"
@@ -15,7 +17,8 @@ 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 {
@@ -36,11 +39,15 @@ class BlockKeyboardAndTouchpadTargeter : public ui::EventTargeter {
   // 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() {
@@ -54,8 +61,25 @@ void BlockKeyboardAndTouchpadTargeter::SetDefaultTargeter(
 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);
 }