Athena's FocusManager

athena/screen/screen_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/screen/public/screen_manager.h"
 
+#include "athena/input/public/accelerator_manager.h"
 #include "athena/screen/background_controller.h"
+#include "athena/screen/screen_accelerator_handler.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
+#include "ui/wm/core/capture_controller.h"
 
 namespace athena {
 namespace {
 
 ScreenManager* instance = NULL;
 
 // TODO(oshima): There seems to be a couple of private implementation which does
 // the same.
 // Consider consolidating and reuse it.
 class FillLayoutManager : public aura::LayoutManager {
@@ skipping 73 matching lines @@
       const std::string& name) OVERRIDE;
   virtual aura::Window* CreateContainer(const std::string& name) OVERRIDE;
   virtual aura::Window* GetContext() OVERRIDE { return root_window_; }
   virtual void SetBackgroundImage(const gfx::ImageSkia& image) OVERRIDE;
 
   aura::Window* root_window_;
   aura::Window* background_window_;
 
   scoped_ptr<BackgroundController> background_controller_;
   scoped_ptr<aura::client::WindowTreeClient> window_tree_client_;
+  scoped_ptr<AcceleratorHandler> accelerator_handler_;
+  scoped_ptr< ::wm::ScopedCaptureClient> capture_client_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenManagerImpl);
 };
 
 void ScreenManagerImpl::Init() {
   root_window_->SetLayoutManager(new FillLayoutManager(root_window_));
   background_window_ =
       CreateContainerInternal(root_window_, "AthenaBackground");
   background_window_->SetLayoutManager(
       new FillLayoutManager(background_window_));
   background_controller_.reset(new BackgroundController(background_window_));
+
+  capture_client_.reset(new ::wm::ScopedCaptureClient(root_window_));
+  accelerator_handler_.reset(new ScreenAcceleratorHandler(root_window_));
 }
 
 aura::Window* ScreenManagerImpl::CreateDefaultContainer(
     const std::string& name) {
   aura::Window* container = CreateContainerInternal(root_window_, name);
   window_tree_client_.reset(new AthenaWindowTreeClient(container));
   aura::client::SetWindowTreeClient(root_window_, window_tree_client_.get());
   return container;
 }
 
@@ skipping 33 matching lines @@
 }
 
 // static
 void ScreenManager::Shutdown() {
   DCHECK(instance);
   delete instance;
   DCHECK(!instance);
 }
 
 }  // namespace athena