Partial fix for keyboard occlusion.

ash/shelf/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/shelf/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "ash/ash_switches.h"
@@ skipping 622 matching lines @@
   bounds->Inset(SelectValueForShelfAlignment(
       gfx::Insets(0, 0, inset, 0),
       gfx::Insets(0, inset, 0, 0),
       gfx::Insets(0, 0, 0, inset),
       gfx::Insets(inset, 0, 0, 0)));
 }
 
 void ShelfLayoutManager::CalculateTargetBounds(
     const State& state,
     TargetBounds* target_bounds) {
-  const gfx::Rect& available_bounds(root_window_->bounds());
+  const gfx::Rect available_bounds(GetAvailableBounds());
   gfx::Rect status_size(
       shelf_->status_area_widget()->GetWindowBoundsInScreen().size());
   int shelf_width = 0, shelf_height = 0;
   GetShelfSize(&shelf_width, &shelf_height);
   if (IsHorizontalAlignment())
     shelf_width = available_bounds.width();
   else
     shelf_height = available_bounds.height();
 
   if (state.visibility_state == SHELF_AUTO_HIDE &&
       state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN) {
     // Auto-hidden shelf always starts with the default size. If a gesture-drag
     // is in progress, then the call to UpdateTargetBoundsForGesture() below
     // takes care of setting the height properly.
     if (IsHorizontalAlignment())
       shelf_height = kAutoHideSize;
     else
       shelf_width = kAutoHideSize;
-  } else if (state.visibility_state == SHELF_HIDDEN) {
+  } else if (state.visibility_state == SHELF_HIDDEN ||
+      !keyboard_bounds_.IsEmpty()) {
     if (IsHorizontalAlignment())
       shelf_height = 0;
     else
       shelf_width = 0;
   }
 
   target_bounds->shelf_bounds_in_root = SelectValueForShelfAlignment(
       gfx::Rect(available_bounds.x(), available_bounds.bottom() - shelf_height,
                     available_bounds.width(), shelf_height),
       gfx::Rect(available_bounds.x(), available_bounds.y(),
@@ skipping 17 matching lines @@
       gfx::Rect(base::i18n::IsRTL() ? 0 : shelf_width - status_size.width(),
                     shelf_height - (status_size.height() + status_inset),
                     status_size.width(), status_size.height()));
 
   target_bounds->work_area_insets = SelectValueForShelfAlignment(
       gfx::Insets(0, 0, GetWorkAreaSize(state, shelf_height), 0),
       gfx::Insets(0, GetWorkAreaSize(state, shelf_width), 0, 0),
       gfx::Insets(0, 0, 0, GetWorkAreaSize(state, shelf_width)),
       gfx::Insets(GetWorkAreaSize(state, shelf_height), 0, 0, 0));
 
+  // Also push in the work area inset for the keyboard if it is visible.
+  if (!keyboard_bounds_.IsEmpty()) {
+    target_bounds->work_area_insets.Set(
+        target_bounds->work_area_insets.top(),
+        target_bounds->work_area_insets.left(),
+        keyboard_bounds_.height(),

[sadrul, 2013/04/26 02:54:16]

If you set bottom to:

  keyboard_bounds_.height() + work_area_insets.bottom();

I suppose that would end up showing the shelf right on top of the keyboard?

[bryeung, 2013/04/26 13:44:50]

When the keyboard is showing, work_area_inserts.bottom() == 0.

Either:
- the shelf is horizontal, and we would have set shelf_height to zero above
- we selected a value with 0 for bottom above

That said, it seems a bit safer and more consistent to include the
work_area_insets.bottom() value.

+        target_bounds->work_area_insets.right());
+  }
+
   target_bounds->opacity =
       (gesture_drag_status_ != GESTURE_DRAG_NONE ||
        state.visibility_state == SHELF_VISIBLE ||
        state.visibility_state == SHELF_AUTO_HIDE) ? 1.0f : 0.0f;
 
   if (gesture_drag_status_ == GESTURE_DRAG_IN_PROGRESS)
     UpdateTargetBoundsForGesture(target_bounds);
 
   // This needs to happen after calling UpdateTargetBoundsForGesture(), because
   // that can change the size of the shelf.
@@ skipping 196 matching lines @@
 }
 
 int ShelfLayoutManager::GetWorkAreaSize(const State& state, int size) const {
   if (state.visibility_state == SHELF_VISIBLE)
     return size;
   if (state.visibility_state == SHELF_AUTO_HIDE)
     return kAutoHideSize;
   return 0;
 }
 
+gfx::Rect ShelfLayoutManager::GetAvailableBounds() const {
+  gfx::Rect bounds(root_window_->bounds());
+  bounds.set_height(bounds.height() - keyboard_bounds_.height());
+  return bounds;
+}
+
+void ShelfLayoutManager::OnKeyboardBoundsChanged(
+    const gfx::Rect& keyboard_bounds) {
+  keyboard_bounds_ = keyboard_bounds;
+  OnWindowResized();
+}
+
 }  // namespace internal
 }  // namespace ash