Do all OOLing in the views code. linux_views now builds clean with the clang plugin.

views/view.cc

 // Copyright (c) 2011 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/view.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 30 matching lines @@
 char View::kViewClassName[] = "views/View";
 
 ////////////////////////////////////////////////////////////////////////////////
 // View, public:
 
 // TO BE MOVED -----------------------------------------------------------------
 
 void View::SetHotTracked(bool flag) {
 }
 
+bool View::IsHotTracked() const {
+  return false;
+}
+
+// FATE TBD --------------------------------------------------------------------
+
+Widget* View::child_widget() {
+  return NULL;
+}
 
 // Creation and lifetime -------------------------------------------------------
 
 View::View()
     : enabled_(true),
       id_(0),
       group_(-1),
       focusable_(false),
       accessibility_focusable_(false),
       is_parent_owned_(true),
@@ skipping 272 matching lines @@
 
     // This notifies all sub-views recursively.
     PropagateVisibilityNotifications(this, flag);
 
     // If we are newly visible, schedule paint.
     if (IsVisible())
       SchedulePaint();
   }
 }
 
+bool View::IsVisible() const {
+  return is_visible_;
+}
+
 bool View::IsVisibleInRootView() const {
   return IsVisible() && parent() ? parent()->IsVisibleInRootView() : false;
 }
 
 void View::SetEnabled(bool state) {
   if (enabled_ != state) {
     enabled_ = state;
     SchedulePaint();
   }
 }
@@ skipping 184 matching lines @@
 void View::SetGroup(int gid) {
   // Don't change the group id once it's set.
   DCHECK(group_ == -1 || group_ == gid);
   group_ = gid;
 }
 
 int View::GetGroup() const {
   return group_;
 }
 
+bool View::IsGroupFocusTraversable() const {
+  return true;
+}
+
 void View::GetViewsWithGroup(int group_id, std::vector<View*>* out) {
   if (group_ == group_id)
     out->push_back(this);
 
   for (int i = 0, count = child_count(); i < count; ++i)
     GetChildViewAt(i)->GetViewsWithGroup(group_id, out);
 }
 
 View* View::GetSelectedViewForGroup(int group_id) {
   std::vector<View*> views;
@@ skipping 300 matching lines @@
   // we should de-register from that focus manager now.
   if (GetWidget() && accelerator_focus_manager_)
     accelerator_focus_manager_->UnregisterAccelerator(accelerator, this);
 }
 
 void View::ResetAccelerators() {
   if (accelerators_.get())
     UnregisterAccelerators(false);
 }
 
+bool View::AcceleratorPressed(const Accelerator& accelerator) {
+  return false;
+}
+
 // Focus -----------------------------------------------------------------------
 
 bool View::HasFocus() {
   FocusManager* focus_manager = GetFocusManager();
   if (focus_manager)
     return focus_manager->GetFocusedView() == this;
   return false;
 }
 
 View* View::GetNextFocusableView() {
@@ skipping 19 matching lines @@
 
 bool View::IsFocusableInRootView() const {
   return IsFocusable() && IsVisibleInRootView();
 }
 
 bool View::IsAccessibilityFocusableInRootView() const {
   return (focusable_ || accessibility_focusable_) && IsEnabled() &&
     IsVisibleInRootView();
 }
 
+void View::set_accessibility_focusable(bool accessibility_focusable) {
+  accessibility_focusable_ = accessibility_focusable;
+}
+
 FocusManager* View::GetFocusManager() {
   Widget* widget = GetWidget();
   return widget ? widget->GetFocusManager() : NULL;
 }
 
 void View::RequestFocus() {
   FocusManager* focus_manager = GetFocusManager();
   if (focus_manager && IsFocusableInRootView())
     focus_manager->SetFocusedView(this);
 }
 
+bool View::SkipDefaultKeyEventProcessing(const KeyEvent& e) {
+  return false;
+}
+
+FocusTraversable* View::GetFocusTraversable() {
+  return NULL;
+}
+
+FocusTraversable* View::GetPaneFocusTraversable() {
+  return NULL;
+}
+
 // Tooltips --------------------------------------------------------------------
 
 bool View::GetTooltipText(const gfx::Point& p, std::wstring* tooltip) {
   return false;
 }
 
 bool View::GetTooltipTextOrigin(const gfx::Point& p, gfx::Point* loc) {
   return false;
 }
 
@@ skipping 57 matching lines @@
   return (abs(delta_x) > GetHorizontalDragThreshold() ||
           abs(delta_y) > GetVerticalDragThreshold());
 }
 
 // Accessibility ---------------------------------------------------------------
 
 void View::NotifyAccessibilityEvent(AccessibilityTypes::Event event_type) {
   NotifyAccessibilityEvent(event_type, true);
 }
 
+string16 View::GetAccessibleDefaultAction() {
+  return string16();
+}
+
+string16 View::GetAccessibleKeyboardShortcut() {
+  return string16();
+}
+
 bool View::GetAccessibleName(string16* name) {
   DCHECK(name);
 
   if (accessible_name_.empty())
     return false;
   *name = accessible_name_;
   return true;
 }
 
 AccessibilityTypes::Role View::GetAccessibleRole() {
   return AccessibilityTypes::ROLE_CLIENT;
 }
 
+AccessibilityTypes::State View::GetAccessibleState() {
+  return 0;
+}
+
+string16 View::GetAccessibleValue() {
+  return string16();
+}
+
 void View::SetAccessibleName(const string16& name) {
   accessible_name_ = name;
 }
 
 // Scrolling -------------------------------------------------------------------
 
 void View::ScrollRectToVisible(const gfx::Rect& rect) {
   // We must take RTL UI mirroring into account when adjusting the position of
   // the region.
   if (parent()) {
@@ skipping 604 matching lines @@
 
   OSExchangeData data;
   WriteDragData(press_pt, &data);
 
   // Message the RootView to do the drag and drop. That way if we're removed
   // the RootView can detect it and avoid calling us back.
   GetWidget()->RunShellDrag(this, data, drag_operations);
 }
 
 }  // namespace views