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

views/view.h

 // 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.
 
 #ifndef VIEWS_VIEW_H_
 #define VIEWS_VIEW_H_
 #pragma once
 
 #include "build/build_config.h"
 
@@ skipping 135 matching lines @@
   // TO BE MOVED ---------------------------------------------------------------
   // TODO(beng): These methods are to be moved to other files/classes.
 
   // TODO(beng): delete
   // Set whether this view is hottracked. A disabled view cannot be hottracked.
   // If flag differs from the current value, SchedulePaint is invoked.
   virtual void SetHotTracked(bool flag);
 
   // TODO(beng): delete
   // Returns whether the view is hot-tracked.
-  virtual bool IsHotTracked() const { return false; }
+  virtual bool IsHotTracked() const;
 
   // FATE TBD ------------------------------------------------------------------
   // TODO(beng): Figure out what these methods are for and delete them.
 
   // TODO(beng): this one isn't even google3-style. wth.
-  virtual Widget* child_widget() { return NULL; }
+  virtual Widget* child_widget();
 
   // Creation and lifetime -----------------------------------------------------
 
   View();
   virtual ~View();
 
   // Set whether this view is owned by its parent. A view that is owned by its
   // parent is automatically deleted when the parent is deleted. The default is
   // true. Set to false if the view is owned by another object and should not
   // be deleted by its parent.
@@ skipping 128 matching lines @@
   // Return the height necessary to display this view with the provided width.
   // View's implementation returns the value from getPreferredSize.cy.
   // Override if your View's preferred height depends upon the width (such
   // as with Labels).
   virtual int GetHeightForWidth(int w);
 
   // Set whether the receiving view is visible. Painting is scheduled as needed
   virtual void SetVisible(bool flag);
 
   // Return whether a view is visible
-  virtual bool IsVisible() const { return is_visible_; }
+  virtual bool IsVisible() const;
 
   // Return whether a view and its ancestors are visible. Returns true if the
   // path from this view to the root view is visible.
   virtual bool IsVisibleInRootView() const;
 
   // Set whether this view is enabled. A disabled view does not receive keyboard
   // or mouse inputs. If flag differs from the current value, SchedulePaint is
   // invoked.
   virtual void SetEnabled(bool flag);
 
@@ skipping 129 matching lines @@
   // Groups are currently used to implement radio button mutual exclusion.
   // The group id is immutable once it's set.
   void SetGroup(int gid);
   // Returns the group id of the view, or -1 if the id is not set yet.
   int GetGroup() const;
 
   // If this returns true, the views from the same group can each be focused
   // when moving focus with the Tab/Shift-Tab key.  If this returns false,
   // only the selected view from the group (obtained with
   // GetSelectedViewForGroup()) is focused.
-  virtual bool IsGroupFocusTraversable() const { return true; }
+  virtual bool IsGroupFocusTraversable() const;
 
   // Fills the provided vector with all the available views which belong to the
   // provided group.
   void GetViewsWithGroup(int group_id, std::vector<View*>* out);
 
   // Return the View that is currently selected in the specified group.
   // The default implementation simply returns the first View found for that
   // group.
   virtual View* GetSelectedViewForGroup(int group_id);
 
@@ skipping 213 matching lines @@
   // Removes the specified accelerator for this view.
   virtual void RemoveAccelerator(const Accelerator& accelerator);
 
   // Removes all the keyboard accelerators for this view.
   virtual void ResetAccelerators();
 
   // TODO(beng): Move to an AcceleratorTarget override section.
   // Called when a keyboard accelerator is pressed.
   // Derived classes should implement desired behavior and return true if they
   // handled the accelerator.
-  virtual bool AcceleratorPressed(const Accelerator& accelerator) {
-    return false;
-  }
+  virtual bool AcceleratorPressed(const Accelerator& accelerator);
 
   // Focus ---------------------------------------------------------------------
 
   // Returns whether this view currently has the focus.
   virtual bool HasFocus();
 
   // Returns the view that should be selected next when pressing Tab.
   View* GetNextFocusableView();
   const View* GetNextFocusableView() const;
 
@@ skipping 16 matching lines @@
   // view. See also IsFocusable.
   bool IsFocusableInRootView() const;
 
   // Return whether this view is focusable when the user requires full keyboard
   // access, even though it may not be normally focusable.
   bool IsAccessibilityFocusableInRootView() const;
 
   // Set whether this view can be made focusable if the user requires
   // full keyboard access, even though it's not normally focusable.
   // Note that this is false by default.
-  virtual void set_accessibility_focusable(bool accessibility_focusable) {
-    accessibility_focusable_ = accessibility_focusable;
-  }
+  virtual void set_accessibility_focusable(bool accessibility_focusable);
 
   // Convenience method to retrieve the FocusManager associated with the
   // Widget that contains this view.  This can return NULL if this view is not
   // part of a view hierarchy with a Widget.
   virtual FocusManager* GetFocusManager();
 
   // Request the keyboard focus. The receiving view will become the
   // focused view.
   virtual void RequestFocus();
 
   // Invoked when a view is about to be requested for focus due to the focus
   // traversal. Reverse is this request was generated going backward
   // (Shift-Tab).
   virtual void AboutToRequestFocusFromTabTraversal(bool reverse) { }
 
   // Invoked when a key is pressed before the key event is processed (and
   // potentially eaten) by the focus manager for tab traversal, accelerators and
   // other focus related actions.
   // The default implementation returns false, ensuring that tab traversal and
   // accelerators processing is performed.
   // Subclasses should return true if they want to process the key event and not
   // have it processed as an accelerator (if any) or as a tab traversal (if the
   // key event is for the TAB key).  In that case, OnKeyPressed will
   // subsequently be invoked for that event.
-  virtual bool SkipDefaultKeyEventProcessing(const KeyEvent& e) {
-    return false;
-  }
+  virtual bool SkipDefaultKeyEventProcessing(const KeyEvent& e);
 
   // Subclasses that contain traversable children that are not directly
   // accessible through the children hierarchy should return the associated
   // FocusTraversable for the focus traversal to work properly.
-  virtual FocusTraversable* GetFocusTraversable() { return NULL; }
+  virtual FocusTraversable* GetFocusTraversable();
 
   // Subclasses that can act as a "pane" must implement their own
   // FocusTraversable to keep the focus trapped within the pane.
   // If this method returns an object, any view that's a direct or
   // indirect child of this view will always use this FocusTraversable
   // rather than the one from the widget.
-  virtual FocusTraversable* GetPaneFocusTraversable() { return NULL; }
+  virtual FocusTraversable* GetPaneFocusTraversable();
 
   // Tooltips ------------------------------------------------------------------
 
   // Gets the tooltip for this View. If the View does not have a tooltip,
   // return false. If the View does have a tooltip, copy the tooltip into
   // the supplied string and return true.
   // Any time the tooltip text that a View is displaying changes, it must
   // invoke TooltipTextChanged.
   // |p| provides the coordinates of the mouse (relative to this view).
   virtual bool GetTooltipText(const gfx::Point& p, std::wstring* tooltip);
@@ skipping 99 matching lines @@
 
   // Raise an accessibility notification with an option to also raise a native
   // notification.
   virtual void NotifyAccessibilityEvent(AccessibilityTypes::Event event_type,
       bool send_native_event);
 
   // Returns the MSAA default action of the current view. The string returned
   // describes the default action that will occur when executing
   // IAccessible::DoDefaultAction. For instance, default action of a button is
   // 'Press'.
-  virtual string16 GetAccessibleDefaultAction() { return string16(); }
+  virtual string16 GetAccessibleDefaultAction();
 
   // Returns a string containing the mnemonic, or the keyboard shortcut, for a
   // given control.
-  virtual string16 GetAccessibleKeyboardShortcut() {
-    return string16();
-  }
+  virtual string16 GetAccessibleKeyboardShortcut();
 
   // Returns a brief, identifying string, containing a unique, readable name of
   // a given control. Sets the input string appropriately, and returns true if
   // successful.
   bool GetAccessibleName(string16* name);
 
   // Returns the accessibility role of the current view. The role is what
   // assistive technologies (ATs) use to determine what behavior to expect from
   // a given control.
   virtual AccessibilityTypes::Role GetAccessibleRole();
 
   // Returns the accessibility state of the current view.
-  virtual AccessibilityTypes::State GetAccessibleState() {
-    return 0;
-  }
+  virtual AccessibilityTypes::State GetAccessibleState();
 
   // Returns the current value associated with a view.
-  virtual string16 GetAccessibleValue() { return string16(); }
+  virtual string16 GetAccessibleValue();
 
   // Assigns a string name to the given control. Needed as a View does not know
   // which name will be associated with it until it is created to be a
   // certain type.
   void SetAccessibleName(const string16& name);
 
   // Returns an instance of the (platform-specific) accessibility interface for
   // the View.
   ViewAccessibility* GetViewAccessibility();
 
@@ skipping 485 matching lines @@
   // The accessibility implementation for this View.
   scoped_refptr<ViewAccessibility> view_accessibility_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(View);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_VIEW_H_