Fix reversed focus traversal order issue.

views/widget/root_view.cc

 // Copyright (c) 2006-2008 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 "views/widget/root_view.h"
 
 #include <algorithm>
 
 #include "app/drag_drop_types.h"
 #include "app/gfx/canvas.h"
@@ skipping 552 matching lines @@
   // Make sure the focused view belongs to this RootView's view hierarchy.
   View* view = focus_manager->GetFocusedView();
   if (view && (view->GetRootView() == this))
     return view;
   return NULL;
 }
 
 View* RootView::FindNextFocusableView(View* starting_view,
                                       bool reverse,
                                       Direction direction,
-                                      bool dont_loop,
+                                      bool check_starting_view,
                                       FocusTraversable** focus_traversable,
                                       View** focus_traversable_view) {
   *focus_traversable = NULL;
   *focus_traversable_view = NULL;
 
   if (GetChildViewCount() == 0) {
     NOTREACHED();
     // Nothing to focus on here.
     return NULL;
   }
 
-  bool skip_starting_view = true;
   if (!starting_view) {
     // Default to the first/last child
     starting_view = reverse ? GetChildViewAt(GetChildViewCount() - 1) :
                               GetChildViewAt(0) ;
     // If there was no starting view, then the one we select is a potential
     // focus candidate.
-    skip_starting_view = false;
+    check_starting_view = true;
   } else {
     // The starting view should be part of this RootView.
     DCHECK(IsParentOf(starting_view));
   }
 
   View* v = NULL;
   if (!reverse) {
-    v = FindNextFocusableViewImpl(starting_view, skip_starting_view,
+    v = FindNextFocusableViewImpl(starting_view, check_starting_view,
                                   true,
                                   (direction == DOWN) ? true : false,
-                                  starting_view->GetGroup());
+                                  starting_view->GetGroup(),
+                                  focus_traversable,
+                                  focus_traversable_view);
   } else {
     // If the starting view is focusable, we don't want to go down, as we are
     // traversing the view hierarchy tree bottom-up.
     bool can_go_down = (direction == DOWN) && !starting_view->IsFocusable();
-    v = FindPreviousFocusableViewImpl(starting_view, true,
+    v = FindPreviousFocusableViewImpl(starting_view, check_starting_view,
                                       true,
                                       can_go_down,
-                                      starting_view->GetGroup());
+                                      starting_view->GetGroup(),
+                                      focus_traversable,
+                                      focus_traversable_view);
   }
+
+  // Doing some sanity checks.
   if (v) {
-    if (v->IsFocusable())
-      return v;
-    *focus_traversable = v->GetFocusTraversable();
-    DCHECK(*focus_traversable);
-    *focus_traversable_view = v;
+    DCHECK(v->IsFocusable());
+    return v;
+  }
+  if (*focus_traversable) {
+    DCHECK(*focus_traversable_view);
     return NULL;
   }
   // Nothing found.
   return NULL;
 }
 
 // Strategy for finding the next focusable view:
 // - keep going down the first child, stop when you find a focusable view or
 //   a focus traversable view (in that case return it) or when you reach a view
 //   with no children.
 // - go to the right sibling and start the search from there (by invoking
 //   FindNextFocusableViewImpl on that view).
 // - if the view has no right sibling, go up the parents until you find a parent
 //   with a right sibling and start the search from there.
 View* RootView::FindNextFocusableViewImpl(View* starting_view,
-                                          bool skip_starting_view,
+                                          bool check_starting_view,
                                           bool can_go_up,
                                           bool can_go_down,
-                                          int skip_group_id) {
-  if (!skip_starting_view) {
+                                          int skip_group_id,
+                                          FocusTraversable** focus_traversable,
+                                          View** focus_traversable_view) {
+  if (check_starting_view) {
     if (IsViewFocusableCandidate(starting_view, skip_group_id))
       return FindSelectedViewForGroup(starting_view);
-    if (starting_view->GetFocusTraversable())
-      return starting_view;
+
+    *focus_traversable = starting_view->GetFocusTraversable();
+    if (*focus_traversable) {
+      *focus_traversable_view = starting_view;
+      return NULL;
+    }
   }
 
   // First let's try the left child.
   if (can_go_down) {
     if (starting_view->GetChildViewCount() > 0) {
       View* v = FindNextFocusableViewImpl(starting_view->GetChildViewAt(0),
-                                          false, false, true, skip_group_id);
-      if (v)
+                                          true, false, true, skip_group_id,
+                                          focus_traversable,
+                                          focus_traversable_view);
+      if (v || *focus_traversable)
         return v;
     }
   }
 
   // Then try the right sibling.
   View* sibling = starting_view->GetNextFocusableView();
   if (sibling) {
     View* v = FindNextFocusableViewImpl(sibling,
-                                        false, false, true, skip_group_id);
-    if (v)
+                                        true, false, true, skip_group_id,
+                                        focus_traversable,
+                                        focus_traversable_view);
+    if (v || *focus_traversable)
       return v;
   }
 
   // Then go up to the parent sibling.
   if (can_go_up) {
     View* parent = starting_view->GetParent();
     while (parent) {
       sibling = parent->GetNextFocusableView();
       if (sibling) {
         return FindNextFocusableViewImpl(sibling,
-                                         false, true, true,
-                                         skip_group_id);
+                                         true, true, true,
+                                         skip_group_id,
+                                         focus_traversable,
+                                         focus_traversable_view);
       }
       parent = parent->GetParent();
     }
   }
 
   // We found nothing.
   return NULL;
 }
 
 // Strategy for finding the previous focusable view:
 // - keep going down on the right until you reach a view with no children, if it
 //   it is a good candidate return it.
 // - start the search on the left sibling.
 // - if there are no left sibling, start the search on the parent (without going
 //   down).
-View* RootView::FindPreviousFocusableViewImpl(View* starting_view,
-                                              bool skip_starting_view,
-                                              bool can_go_up,
-                                              bool can_go_down,
-                                              int skip_group_id) {
+View* RootView::FindPreviousFocusableViewImpl(
+    View* starting_view,
+    bool check_starting_view,
+    bool can_go_up,
+    bool can_go_down,
+    int skip_group_id,
+    FocusTraversable** focus_traversable,
+    View** focus_traversable_view) {
   // Let's go down and right as much as we can.
   if (can_go_down) {
+    // Before we go into the direct children, we have to check if this view has
+    // a FocusTraversable.
+    *focus_traversable = starting_view->GetFocusTraversable();
+    if (*focus_traversable) {
+      *focus_traversable_view = starting_view;
+      return NULL;
+    }
+
     if (starting_view->GetChildViewCount() > 0) {
       View* view =
           starting_view->GetChildViewAt(starting_view->GetChildViewCount() - 1);
-      View* v = FindPreviousFocusableViewImpl(view, false, false, true,
-                                              skip_group_id);
-      if (v)
+      View* v = FindPreviousFocusableViewImpl(view, true, false, true,
+                                              skip_group_id,
+                                              focus_traversable,
+                                              focus_traversable_view);
+      if (v || *focus_traversable)
         return v;
     }
   }
 
-  if (!skip_starting_view) {
-    if (IsViewFocusableCandidate(starting_view, skip_group_id))
-      return FindSelectedViewForGroup(starting_view);
-    if (starting_view->GetFocusTraversable())
-      return starting_view;
+  // Then look at this view. Here, we do not need to see if the view has
+  // a FocusTraversable, since we do not want to go down any more.
+  if (check_starting_view &&
+      IsViewFocusableCandidate(starting_view, skip_group_id)) {
+    return FindSelectedViewForGroup(starting_view);
   }
 
   // Then try the left sibling.
   View* sibling = starting_view->GetPreviousFocusableView();
   if (sibling) {
     return FindPreviousFocusableViewImpl(sibling,
-                                         false, true, true,
-                                         skip_group_id);
+                                         true, true, true,
+                                         skip_group_id,
+                                         focus_traversable,
+                                         focus_traversable_view);
   }
 
   // Then go up the parent.
   if (can_go_up) {
     View* parent = starting_view->GetParent();
     if (parent)
       return FindPreviousFocusableViewImpl(parent,
-                                           false, true, false,
-                                           skip_group_id);
+                                           true, true, false,
+                                           skip_group_id,
+                                           focus_traversable,
+                                           focus_traversable_view);
   }
 
   // We found nothing.
   return NULL;
 }
 
 FocusTraversable* RootView::GetFocusTraversableParent() {
   return focus_traversable_parent_;
 }
 
@@ skipping 181 matching lines @@
     previous_cursor_ = NULL;
   }
 #elif defined(OS_LINUX)
   gdk_window_set_cursor(GetWidget()->GetNativeView()->window, cursor);
   if (cursor)
     gdk_cursor_destroy(cursor);
 #endif
 }
 
 }  // namespace views