Migrate Event API methods to Google Style.

views/focus/focus_manager.cc

 // Copyright (c) 2010 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/focus/focus_manager.h"
 
 #include <algorithm>
 
 #include "build/build_config.h"
 
@@ skipping 102 matching lines @@
     return false;
   }
 #else
   if (IsTabTraversalKeyEvent(event)) {
     AdvanceFocus(event.IsShiftDown());
     return false;
   }
 #endif
 
   // Intercept arrow key messages to switch between grouped views.
-  ui::KeyboardCode key_code = event.GetKeyCode();
+  ui::KeyboardCode key_code = event.key_code();
   if (focused_view_ && focused_view_->GetGroup() != -1 &&
       (key_code == ui::VKEY_UP || key_code == ui::VKEY_DOWN ||
        key_code == ui::VKEY_LEFT || key_code == ui::VKEY_RIGHT)) {
     bool next = (key_code == ui::VKEY_RIGHT || key_code == ui::VKEY_DOWN);
     std::vector<View*> views;
     focused_view_->parent()->GetViewsWithGroup(focused_view_->GetGroup(),
                                                &views);
     std::vector<View*>::const_iterator iter = std::find(views.begin(),
                                                         views.end(),
                                                         focused_view_);
     DCHECK(iter != views.end());
     int index = static_cast<int>(iter - views.begin());
     index += next ? 1 : -1;
     if (index < 0) {
       index = static_cast<int>(views.size()) - 1;
     } else if (index >= static_cast<int>(views.size())) {
       index = 0;
     }
     SetFocusedViewWithReason(views[index], kReasonFocusTraversal);
     return false;
   }
 
   // Process keyboard accelerators.
   // If the key combination matches an accelerator, the accelerator is
   // triggered, otherwise the key event is processed as usual.
-  Accelerator accelerator(event.GetKeyCode(),
+  Accelerator accelerator(event.key_code(),
                           event.IsShiftDown(),
                           event.IsControlDown(),
                           event.IsAltDown());
   if (ProcessAccelerator(accelerator)) {
     // If a shortcut was activated for this keydown message, do not propagate
     // the event further.
     return false;
   }
   return true;
 }
@@ skipping 342 matching lines @@
 AcceleratorTarget* FocusManager::GetCurrentTargetForAccelerator(
     const views::Accelerator& accelerator) const {
   AcceleratorMap::const_iterator map_iter = accelerators_.find(accelerator);
   if (map_iter == accelerators_.end() || map_iter->second.empty())
     return NULL;
   return map_iter->second.front();
 }
 
 // static
 bool FocusManager::IsTabTraversalKeyEvent(const KeyEvent& key_event) {
-  return key_event.GetKeyCode() == ui::VKEY_TAB &&
-         !key_event.IsControlDown();
+  return key_event.key_code() == ui::VKEY_TAB && !key_event.IsControlDown();
 }
 
 void FocusManager::ViewRemoved(View* parent, View* removed) {
   if (focused_view_ && focused_view_ == removed)
     ClearFocus();
 }
 
 void FocusManager::AddFocusChangeListener(FocusChangeListener* listener) {
   DCHECK(std::find(focus_change_listeners_.begin(),
                    focus_change_listeners_.end(), listener) ==
       focus_change_listeners_.end()) << "Adding a listener twice.";
   focus_change_listeners_.push_back(listener);
 }
 
 void FocusManager::RemoveFocusChangeListener(FocusChangeListener* listener) {
   FocusChangeListenerList::iterator place =
       std::find(focus_change_listeners_.begin(), focus_change_listeners_.end(),
                 listener);
   if (place == focus_change_listeners_.end()) {
     NOTREACHED() << "Removing a listener that isn't registered.";
     return;
   }
   focus_change_listeners_.erase(place);
 }
 
 }  // namespace views