MacViews: Fix duplicate definition of ExtensionKeyBindingRegistry::SetShortcutHandlingSuspended

athena/input/accelerator_manager_impl.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 "athena/input/accelerator_manager_impl.h"
 
 #include "athena/input/public/input_manager.h"
 #include "athena/util/switches.h"
 #include "base/logging.h"
 #include "ui/aura/window.h"
 #include "ui/base/accelerators/accelerator_manager.h"
+#include "ui/base/accelerators/accelerator_processor.h"
 #include "ui/events/event.h"
 #include "ui/events/event_target.h"
 #include "ui/views/focus/focus_manager.h"
-#include "ui/views/focus/focus_manager_delegate.h"
 #include "ui/views/focus/focus_manager_factory.h"
 #include "ui/wm/core/accelerator_delegate.h"
 #include "ui/wm/core/accelerator_filter.h"
 #include "ui/wm/core/nested_accelerator_controller.h"
 #include "ui/wm/core/nested_accelerator_delegate.h"
 #include "ui/wm/public/dispatcher_client.h"
 
 namespace athena {
 
 // This wrapper interface provides a common interface that handles global
@@ skipping 55 matching lines @@
       return false;
     }
     return accelerator_manager_->Process(accelerator);
   }
 
   AcceleratorManagerImpl* accelerator_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(AcceleratorDelegate);
 };
 
-class FocusManagerDelegate : public views::FocusManagerDelegate {
+class AcceleratorProcessor : public ui::AcceleratorProcessor {
  public:
-  explicit FocusManagerDelegate(AcceleratorManagerImpl* accelerator_manager)
+  explicit AcceleratorProcessor(AcceleratorManagerImpl* accelerator_manager)
       : accelerator_manager_(accelerator_manager) {}
-  ~FocusManagerDelegate() override {}
+  ~AcceleratorProcessor() override {}
 
   bool ProcessAccelerator(const ui::Accelerator& accelerator) override {
     return accelerator_manager_->Process(accelerator);
   }
 
-  ui::AcceleratorTarget* GetCurrentTargetForAccelerator(
+  ui::AcceleratorTarget* GetTargetForAccelerator(
       const ui::Accelerator& accelerator) const override {
     return accelerator_manager_->IsRegistered(accelerator, AF_NONE)
                ? accelerator_manager_
                : nullptr;
   }
 
  private:
   AcceleratorManagerImpl* accelerator_manager_;
 
-  DISALLOW_COPY_AND_ASSIGN(FocusManagerDelegate);
+  DISALLOW_COPY_AND_ASSIGN(AcceleratorProcessor);
 };
 
 // Key strokes must be sent to web contents to give them a chance to
 // consume them unless they are reserved, and unhandled key events are
 // sent back to focus manager asynchronously. This installs the athena's
 // focus manager that handles athena shell's accelerators.
 class FocusManagerFactory : public views::FocusManagerFactory {
  public:
   explicit FocusManagerFactory(AcceleratorManagerImpl* accelerator_manager)
       : accelerator_manager_(accelerator_manager) {}
   ~FocusManagerFactory() override {}
 
   views::FocusManager* CreateFocusManager(views::Widget* widget,
                                           bool desktop_widget) override {
-    return new views::FocusManager(
-        widget,
-        desktop_widget ? nullptr
-                       : new FocusManagerDelegate(accelerator_manager_));
+    views::FocusManager* focus_manager = new views::FocusManager(widget);
+    if (!desktop_widget) {
+      focus_manager->AddAcceleratorPostProcessor(
+          new AcceleratorProcessor(accelerator_manager_));
+    }
+    return focus_manager;
   }
 
  private:
   AcceleratorManagerImpl* accelerator_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusManagerFactory);
 };
 
 class UIAcceleratorManagerWrapper
     : public AcceleratorManagerImpl::AcceleratorWrapper {
  public:
   UIAcceleratorManagerWrapper()
       : ui_accelerator_manager_(new ui::AcceleratorManager) {}
   ~UIAcceleratorManagerWrapper() override {}
 
   virtual void Register(const ui::Accelerator& accelerator,
                         ui::AcceleratorTarget* target) override {
     ui_accelerator_manager_->Register(
         accelerator, ui::AcceleratorManager::kNormalPriority, target);
   }
 
   virtual void Unregister(const ui::Accelerator& accelerator,
                           ui::AcceleratorTarget* target) override {
     ui_accelerator_manager_->Unregister(accelerator, target);
   }
 
   virtual bool Process(const ui::Accelerator& accelerator) override {
-    return ui_accelerator_manager_->Process(accelerator);
+    return ui_accelerator_manager_->ProcessAccelerator(accelerator);
   }
 
   virtual ui::AcceleratorTarget* GetCurrentTarget(
       const ui::Accelerator& accelerator) const override {
-    return ui_accelerator_manager_->GetCurrentTarget(accelerator);
+    return ui_accelerator_manager_->GetTargetForAccelerator(accelerator);
   }
 
  private:
   scoped_ptr<ui::AcceleratorManager> ui_accelerator_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(UIAcceleratorManagerWrapper);
 };
 
 class FocusManagerWrapper : public AcceleratorManagerImpl::AcceleratorWrapper {
  public:
@@ skipping 12 matching lines @@
     focus_manager_->UnregisterAccelerator(accelerator, target);
   }
 
   virtual bool Process(const ui::Accelerator& accelerator) override {
     NOTREACHED();
     return true;
   }
 
   virtual ui::AcceleratorTarget* GetCurrentTarget(
       const ui::Accelerator& accelerator) const override {
-    return focus_manager_->GetCurrentTargetForAccelerator(accelerator);
+    return focus_manager_->GetTargetForAccelerator(accelerator);
   }
 
  private:
   views::FocusManager* focus_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusManagerWrapper);
 };
 
 }  // namespace
 
@@ skipping 153 matching lines @@
   return InputManager::Get()->GetAcceleratorManager();
 }
 
 // static
 scoped_ptr<AcceleratorManager> AcceleratorManager::CreateForFocusManager(
     views::FocusManager* focus_manager) {
   return AcceleratorManagerImpl::CreateForFocusManager(focus_manager).Pass();
 }
 
 }  // namespace athena