Add left/right layout support for uber tray.

ash/wm/shelf_layout_manager.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 "ash/wm/shelf_layout_manager.h"
 
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
@@ skipping 175 matching lines @@
   LayoutShelf();
 }
 
 void ShelfLayoutManager::SetAlignment(ShelfAlignment alignment) {
   if (alignment_ == alignment)
     return;
 
   alignment_ = alignment;
   if (launcher_)
     launcher_->SetAlignment(alignment);
+  if (Shell::GetInstance()->tray())
+    Shell::GetInstance()->tray()->SetAlignment(alignment);
   LayoutShelf();
 }
 
 gfx::Rect ShelfLayoutManager::GetIdealBounds() {
   // TODO: this is wrong. Figure out what monitor shelf is on and everything
   // should be based on it.
   gfx::Rect bounds(
       gfx::Screen::GetMonitorNearestWindow(status_->GetNativeView()).bounds());
   int width = 0, height = 0;
   GetShelfSize(&width, &height);
@@ skipping 179 matching lines @@
 }
 
 void ShelfLayoutManager::StopAnimating() {
   if (launcher_widget())
     GetLayer(launcher_widget())->GetAnimator()->StopAnimating();
   GetLayer(status_)->GetAnimator()->StopAnimating();
 }
 
 void ShelfLayoutManager::GetShelfSize(int* width, int* height) {
   *width = *height = 0;
-  gfx::Rect status_bounds(status_->GetWindowScreenBounds());
+  gfx::Size status_size = Shell::GetInstance()->tray() ?
+      status_->GetContentsView()->GetPreferredSize() : gfx::Size();
   gfx::Size launcher_size = launcher_ ?
       launcher_widget()->GetContentsView()->GetPreferredSize() : gfx::Size();
-  if (alignment_ == SHELF_ALIGNMENT_BOTTOM) {
-    *height = std::max(launcher_size.height(), status_bounds.height());
-  } else {
-    // TODO: include status when supports alignment.
-    *width = launcher_size.width();
-  }
+  if (alignment_ == SHELF_ALIGNMENT_BOTTOM)
+    *height = std::max(launcher_size.height(), status_size.height());
+  else
+    *width = std::max(launcher_size.width(), status_size.width());
 }
 
 void ShelfLayoutManager::AdjustBoundsBasedOnAlignment(int inset,
                                                       gfx::Rect* bounds) const {
   switch (alignment_) {
     case SHELF_ALIGNMENT_BOTTOM:
       bounds->Inset(gfx::Insets(0, 0, inset, 0));
       break;
     case SHELF_ALIGNMENT_LEFT:
       bounds->Inset(gfx::Insets(0, inset, 0, 0));
       break;
     case SHELF_ALIGNMENT_RIGHT:
       bounds->Inset(gfx::Insets(0, 0, 0, inset));
       break;
   }
 }
 
 void ShelfLayoutManager::CalculateTargetBounds(
     const State& state,
     TargetBounds* target_bounds) {
   const gfx::Rect& available_bounds(
       status_->GetNativeView()->GetRootWindow()->bounds());
-  gfx::Rect status_bounds(status_->GetWindowScreenBounds());
+  gfx::Size status_size = Shell::GetInstance()->tray() ?
+      status_->GetContentsView()->GetPreferredSize() : gfx::Size();
+
   gfx::Size launcher_size = launcher_ ?
       launcher_widget()->GetContentsView()->GetPreferredSize() : gfx::Size();
   int shelf_size = 0;
   int shelf_width = 0, shelf_height = 0;
   GetShelfSize(&shelf_width, &shelf_height);
   if (state.visibility_state == VISIBLE ||
       (state.visibility_state == AUTO_HIDE &&
        state.auto_hide_state == AUTO_HIDE_SHOWN)) {
     shelf_size = std::max(shelf_width, shelf_height);
   } else if (state.visibility_state == AUTO_HIDE &&
              state.auto_hide_state == AUTO_HIDE_HIDDEN) {
     shelf_size = kAutoHideSize;
   }
   if (alignment_ == SHELF_ALIGNMENT_BOTTOM) {
     int y = available_bounds.bottom();
     y -= shelf_size;
     // The status widget should extend to the bottom and right edges.
     target_bounds->status_bounds = gfx::Rect(
         base::i18n::IsRTL() ? available_bounds.x() :
-        available_bounds.right() - status_bounds.width(),
-        y + shelf_height - status_bounds.height(),
-        status_bounds.width(), status_bounds.height());
+        available_bounds.right() - status_size.width(),
+        y + shelf_height - status_size.height(),
+        status_size.width(), status_size.height());
+
     if (launcher_widget()) {
       target_bounds->launcher_bounds = gfx::Rect(
           available_bounds.x(),
           y + (shelf_height - launcher_size.height()) / 2,
           available_bounds.width(),
           launcher_size.height());
     }
     target_bounds->work_area_insets.Set(
         0, 0, GetWorkAreaSize(state, shelf_height), 0);
   } else {
     int x = (alignment_ == SHELF_ALIGNMENT_LEFT) ?
         available_bounds.x() + shelf_size - shelf_width :
         available_bounds.right() - shelf_size;
     target_bounds->status_bounds = gfx::Rect(
-        x, available_bounds.bottom() - status_bounds.height(),
-        shelf_width, status_bounds.height());
+        x, available_bounds.bottom() - status_size.height(),
+        shelf_width, status_size.height());
     if (launcher_widget()) {
       target_bounds->launcher_bounds = gfx::Rect(
           x,
           available_bounds.y(),
           launcher_size.width(),
           available_bounds.height());
     }
     if (alignment_ == SHELF_ALIGNMENT_LEFT) {
       target_bounds->work_area_insets.Set(
           0, GetWorkAreaSize(state, shelf_width), 0, 0);
@@ skipping 92 matching lines @@
 int ShelfLayoutManager::GetWorkAreaSize(const State& state, int size) const {
   if (state.visibility_state == VISIBLE)
     return size;
   if (state.visibility_state == AUTO_HIDE)
     return kAutoHideSize;
   return 0;
 }
 
 }  // namespace internal
 }  // namespace ash