Add initial home card impl.

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/screen/background_controller.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/aura/client/window_tree_client.h"
@@ skipping 55 matching lines @@
                                          aura::Window* window,
                                          const gfx::Rect& bounds) OVERRIDE {
     return container_;
   }
 
   aura::Window* container_;
 
   DISALLOW_COPY_AND_ASSIGN(AthenaWindowTreeClient);
 };
 
-aura::Window* CreateContainer(aura::Window* parent, const std::string& name) {
+aura::Window* CreateContainerInternal(aura::Window* parent,
+                                      const std::string& name) {
   aura::Window* container = new aura::Window(NULL);
   container->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   container->SetName(name);
   parent->AddChild(container);
   container->Show();
   return container;
 }
 
 class ScreenManagerImpl : public ScreenManager {
  public:
   explicit ScreenManagerImpl(aura::Window* root_window);
   virtual ~ScreenManagerImpl();
 
   void Init();
 
  private:
-  // Screenmanager:
-  virtual aura::Window* GetContainerWindow() OVERRIDE { return container_; }
+  // ScreenManager:
+  virtual aura::Window* CreateDefaultContainer(
+      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_;
-  // A container used for apps/web windows.
-  aura::Window* container_;
   aura::Window* background_window_;
+
   scoped_ptr<BackgroundController> background_controller_;
   scoped_ptr<aura::client::WindowTreeClient> window_tree_client_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenManagerImpl);
 };
 
 void ScreenManagerImpl::Init() {
   root_window_->SetLayoutManager(new FillLayoutManager(root_window_));
-  background_window_ = CreateContainer(root_window_, "AthenaBackground");
+  background_window_ =
+      CreateContainerInternal(root_window_, "AthenaBackground");
   background_window_->SetLayoutManager(
       new FillLayoutManager(background_window_));
   background_controller_.reset(new BackgroundController(background_window_));
-  container_ = CreateContainer(root_window_, "AthenaContainer");
+}
 
-  window_tree_client_.reset(new AthenaWindowTreeClient(container_));
+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;
+}
+
+aura::Window* ScreenManagerImpl::CreateContainer(const std::string& name) {
+  return CreateContainerInternal(root_window_, name);
 }
 
 void ScreenManagerImpl::SetBackgroundImage(const gfx::ImageSkia& image) {
   background_controller_->SetImage(image);
 }
 
 ScreenManagerImpl::ScreenManagerImpl(aura::Window* root_window)
     : root_window_(root_window) {
   DCHECK(root_window_);
   DCHECK(!instance);
@@ skipping 21 matching lines @@
 }
 
 // static
 void ScreenManager::Shutdown() {
   DCHECK(instance);
   delete instance;
   DCHECK(!instance);
 }
 
 }  // namespace athena