Revert 150420 - Accelerator support for browserless panels on Windows.

chrome/browser/ui/panels/panel_view.cc

 // Copyright (c) 2012 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 "chrome/browser/ui/panels/panel_view.h"
 
 #include "base/logging.h"
-#include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_bounds_animation.h"
 #include "chrome/browser/ui/panels/panel_frame_view.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/webview/webview.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(OS_WIN) && !defined(USE_ASH) && !defined(USE_AURA)
 #include "base/win/windows_version.h"
 #include "chrome/browser/ui/panels/taskbar_window_thumbnailer_win.h"
 #endif
 
 namespace {
 
-// Supported accelerators.
-// Note: We can't use the acclerator table defined in chrome/browser/ui/views
-// due to checkdeps violation.
-struct AcceleratorMapping {
-  ui::KeyboardCode keycode;
-  int modifiers;
-  int command_id;
-};
-const AcceleratorMapping kPanelAcceleratorMap[] = {
-  { ui::VKEY_W, ui::EF_CONTROL_DOWN, IDC_CLOSE_WINDOW },
-  { ui::VKEY_W, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN, IDC_CLOSE_WINDOW },
-  { ui::VKEY_F4, ui::EF_ALT_DOWN, IDC_CLOSE_WINDOW },
-  { ui::VKEY_R, ui::EF_CONTROL_DOWN, IDC_RELOAD },
-  { ui::VKEY_F5, ui::EF_NONE, IDC_RELOAD },
-  { ui::VKEY_R, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
-      IDC_RELOAD_IGNORING_CACHE },
-  { ui::VKEY_F5, ui::EF_CONTROL_DOWN, IDC_RELOAD_IGNORING_CACHE },
-  { ui::VKEY_F5, ui::EF_SHIFT_DOWN, IDC_RELOAD_IGNORING_CACHE },
-  { ui::VKEY_ESCAPE, ui::EF_NONE, IDC_STOP },
-  { ui::VKEY_OEM_MINUS, ui::EF_CONTROL_DOWN, IDC_ZOOM_MINUS },
-  { ui::VKEY_SUBTRACT, ui::EF_CONTROL_DOWN, IDC_ZOOM_MINUS },
-  { ui::VKEY_0, ui::EF_CONTROL_DOWN, IDC_ZOOM_NORMAL },
-  { ui::VKEY_NUMPAD0, ui::EF_CONTROL_DOWN, IDC_ZOOM_NORMAL },
-  { ui::VKEY_OEM_PLUS, ui::EF_CONTROL_DOWN, IDC_ZOOM_PLUS },
-  { ui::VKEY_ADD, ui::EF_CONTROL_DOWN, IDC_ZOOM_PLUS },
-};
-
 // NativePanelTesting implementation.
 class NativePanelTestingWin : public NativePanelTesting {
  public:
   explicit NativePanelTestingWin(PanelView* panel_view);
 
  private:
   virtual void PressLeftMouseButtonTitlebar(
       const gfx::Point& mouse_location, panel::ClickModifier modifier) OVERRIDE;
   virtual void ReleaseMouseButtonTitlebar(
       panel::ClickModifier modifier) OVERRIDE;
@@ skipping 72 matching lines @@
   return false;
 }
 
 }  // namespace
 
 // static
 NativePanel* Panel::CreateNativePanel(Panel* panel, const gfx::Rect& bounds) {
   return new PanelView(panel, bounds);
 }
 
-// static
-std::map<ui::Accelerator, int> PanelView::accelerator_table_;
-
 PanelView::PanelView(Panel* panel, const gfx::Rect& bounds)
     : panel_(panel),
       window_(NULL),
       web_view_(NULL),
       focused_(false),
       mouse_pressed_(false),
       mouse_dragging_state_(NO_DRAGGING),
       is_drawing_attention_(false),
       force_to_paint_as_inactive_(false),
       old_focused_view_(NULL) {
   window_ = new views::Widget;
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_PANEL);
   params.delegate = this;
   params.remove_standard_frame = true;
   params.keep_on_top = true;
   params.bounds = bounds;
   window_->Init(params);
   window_->set_frame_type(views::Widget::FRAME_TYPE_FORCE_CUSTOM);
   window_->set_focus_on_creation(false);
   window_->AddObserver(this);
 
   web_view_ = new views::WebView(NULL);
   AddChildView(web_view_);
 
   OnViewWasResized();
 
-  // Do a one-time initialization for the accelerator table.
-  if (accelerator_table_.empty()) {
-    for (size_t i = 0; i < arraysize(kPanelAcceleratorMap); ++i) {
-      ui::Accelerator accelerator(kPanelAcceleratorMap[i].keycode,
-                                  kPanelAcceleratorMap[i].modifiers);
-      accelerator_table_[accelerator] = kPanelAcceleratorMap[i].command_id;
-    }
-  }
-
-  // Register accelarators supported by panels.
   views::FocusManager* focus_manager = GetFocusManager();
-  for (std::map<ui::Accelerator, int>::const_iterator iter =
-           accelerator_table_.begin();
-       iter != accelerator_table_.end(); ++iter) {
-    focus_manager->RegisterAccelerator(
-        iter->first, ui::AcceleratorManager::kNormalPriority, this);
-  }
+  ui::Accelerator accelerator(ui::VKEY_ESCAPE, ui::EF_NONE);
+  focus_manager->RegisterAccelerator(
+        accelerator, ui::AcceleratorManager::kNormalPriority, this);
 }
 
 PanelView::~PanelView() {
   web_view_->SetWebContents(NULL);
 }
 
 void PanelView::ShowPanel() {
   ShowPanelInactive();
   ActivatePanel();
 }
@@ skipping 140 matching lines @@
 }
 
 bool PanelView::PreHandlePanelKeyboardEvent(
     const content::NativeWebKeyboardEvent& event,
     bool* is_keyboard_shortcut) {
   return false;
 }
 
 void PanelView::HandlePanelKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
-  views::FocusManager* focus_manager = GetFocusManager();
-  if (focus_manager->shortcut_handling_suspended())
-    return;
-
-  ui::Accelerator accelerator(
-      static_cast<ui::KeyboardCode>(event.windowsKeyCode),
-      content::GetModifiersFromNativeWebKeyboardEvent(event));
-  if (event.type == WebKit::WebInputEvent::KeyUp)
-    accelerator.set_type(ui::ET_KEY_RELEASED);
-  focus_manager->ProcessAccelerator(accelerator);
 }
 
 void PanelView::FullScreenModeChanged(bool is_full_screen) {
   if (is_full_screen) {
     if (window_->IsVisible())
       window_->Hide();
   } else {
     ShowPanelInactive();
   }
 }
@@ skipping 193 matching lines @@
 bool PanelView::AcceleratorPressed(const ui::Accelerator& accelerator) {
   if (mouse_pressed_ && accelerator.key_code() == ui::VKEY_ESCAPE) {
     OnTitlebarMouseCaptureLost();
     return true;
   }
 
   // No other accelerator is allowed when the drag begins.
   if (mouse_dragging_state_ == DRAGGING_STARTED)
     return true;
 
-  std::map<ui::Accelerator, int>::const_iterator iter =
-      accelerator_table_.find(accelerator);
-  DCHECK(iter != accelerator_table_.end());
-  return panel_->ExecuteCommandIfEnabled(iter->second);
+  return views::View::AcceleratorPressed(accelerator);
 }
 
 void PanelView::OnWidgetActivationChanged(views::Widget* widget, bool active) {
 #if defined(OS_WIN) && !defined(USE_AURA)
   // The panel window is in focus (actually accepting keystrokes) if it is
   // active and belongs to a foreground application.
   bool focused = active &&
       GetFrameView()->GetWidget()->GetNativeView() == ::GetForegroundWindow();
 #else
   NOTIMPLEMENTED();
@@ skipping 145 matching lines @@
   int height = web_view_->size().height();
   SkRegion* region = new SkRegion;
   region->op(0, 0, kResizeInsideBoundsSize, height, SkRegion::kUnion_Op);
   region->op(width - kResizeInsideBoundsSize, 0, width, height,
       SkRegion::kUnion_Op);
   region->op(0, height - kResizeInsideBoundsSize, width, height,
       SkRegion::kUnion_Op);
   web_contents->GetRenderViewHost()->GetView()->SetClickthroughRegion(region);
 #endif
 }