Make the minimized home card not overlap activities on Athena

athena/screen/screen_manager_impl.cc

Index: athena/screen/screen_manager_impl.cc
diff --git a/athena/screen/screen_manager_impl.cc b/athena/screen/screen_manager_impl.cc
index 2c9c76401c1f8c02b2fd90e83ef20349bb4dbbba..dc433793da02b4b95ddc4ba6672ee2ce90ffa586 100644
--- a/athena/screen/screen_manager_impl.cc
+++ b/athena/screen/screen_manager_impl.cc
@@ -8,6 +8,7 @@
 #include "athena/common/fill_layout_manager.h"
 #include "athena/input/public/accelerator_manager.h"
 #include "athena/screen/background_controller.h"
+#include "athena/screen/public/screen_manager_delegate.h"
 #include "athena/screen/screen_accelerator_handler.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ -19,6 +20,10 @@
 #include "ui/aura/window_targeter.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/compositor/layer.h"
+#include "ui/gfx/display.h"
+#include "ui/gfx/insets.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/screen.h"
 #include "ui/wm/core/base_focus_rules.h"
 #include "ui/wm/core/capture_controller.h"
 
@@ -188,13 +193,16 @@ class AthenaEventTargeter : public aura::WindowTargeter,
 
 class ScreenManagerImpl : public ScreenManager {
  public:
-  explicit ScreenManagerImpl(aura::Window* root_window);
+  explicit ScreenManagerImpl(ScreenManagerDelegate* delegate,
+                             aura::Window* root_window);
   virtual ~ScreenManagerImpl();
 
   void Init();
 
  private:
   // ScreenManager:
+  virtual gfx::Rect GetWorkArea() OVERRIDE;
+  virtual void SetWorkAreaInsets(const gfx::Insets& insets) OVERRIDE;
   virtual aura::Window* CreateDefaultContainer(
       const ContainerParams& params) OVERRIDE;
   virtual aura::Window* CreateContainer(const ContainerParams& params) OVERRIDE;
@@ -202,6 +210,8 @@ class ScreenManagerImpl : public ScreenManager {
   virtual void SetBackgroundImage(const gfx::ImageSkia& image) OVERRIDE;
   virtual ui::LayerAnimator* GetScreenAnimator() OVERRIDE;
 
+  // Not owned.
+  ScreenManagerDelegate* delegate_;
   aura::Window* root_window_;
   aura::Window* background_window_;
 
@@ -214,8 +224,10 @@ class ScreenManagerImpl : public ScreenManager {
   DISALLOW_COPY_AND_ASSIGN(ScreenManagerImpl);
 };
 
-ScreenManagerImpl::ScreenManagerImpl(aura::Window* root_window)
-    : root_window_(root_window) {
+ScreenManagerImpl::ScreenManagerImpl(ScreenManagerDelegate* delegate,
+                                     aura::Window* root_window)
+    : delegate_(delegate),
+      root_window_(root_window) {
   DCHECK(root_window_);
   DCHECK(!instance);
   instance = this;
@@ -241,6 +253,16 @@ void ScreenManagerImpl::Init() {
   accelerator_handler_.reset(new ScreenAcceleratorHandler(root_window_));
 }
 
+gfx::Rect ScreenManagerImpl::GetWorkArea() {
+  return gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area();
+}
+
+void ScreenManagerImpl::SetWorkAreaInsets(const gfx::Insets& insets) {
+  // |delegate_| may be NULL in tests.
+  if (delegate_)
+    delegate_->SetWorkAreaInsets(insets);
+}
+
 aura::Window* ScreenManagerImpl::CreateDefaultContainer(
     const ContainerParams& params) {
   aura::Window* container = CreateContainer(params);
@@ -339,8 +361,9 @@ ScreenManager::ContainerParams::ContainerParams(const std::string& n,
 }
 
 // static
-ScreenManager* ScreenManager::Create(aura::Window* root_window) {
-  (new ScreenManagerImpl(root_window))->Init();
+ScreenManager* ScreenManager::Create(ScreenManagerDelegate* delegate,
+                                     aura::Window* root_window) {
+  (new ScreenManagerImpl(delegate, root_window))->Init();
   DCHECK(instance);
   return instance;
 }