Small changes such as spacing and adding [in/out] identifiers after @params.

ppapi/cpp/paint_manager.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 PPAPI_CPP_PAINT_MANAGER_H_
 #define PPAPI_CPP_PAINT_MANAGER_H_
 
 #include <vector>
 
 #include "ppapi/cpp/completion_callback.h"
@@ skipping 72 matching lines @@
     /// automatically if you return true from this function since the
     /// <code>PaintManager</code> needs to handle the callback.
     ///
     /// It is legal for you to cause invalidates inside of Paint which will
     /// then get executed as soon as the Flush for this update has completed.
     /// However, this is not very nice to the host system since it will spin the
     /// CPU, possibly updating much faster than necessary. It is best to have a
     /// 1/60 second timer to do an invalidate instead. This will limit your
     /// animation to the slower of 60Hz or "however fast Flush can complete."
     ///
-    /// @param graphics A <code>Graphics2D</code> to be painted.
-    /// @param paint_rects A list of rects to paint.
-    /// @param paint_bounds A union of the rects to paint.
+    /// @param[in] graphics A <code>Graphics2D</code> to be painted.
+    /// @param[in] paint_rects A list of rects to paint.
+    /// @param[in] paint_bounds A union of the rects to paint.
+    ///
+    /// @return true if successful, otherwise false.
     virtual bool OnPaint(Graphics2D& graphics,
                          const std::vector<Rect>& paint_rects,
                          const Rect& paint_bounds) = 0;
 
    protected:
     // You shouldn't be doing deleting through this interface.
     virtual ~Client() {}
   };
 
   /// Default constructor for creating an is_null() <code>PaintManager</code>
@@ skipping 42 matching lines @@
   /// paint manager).
   /// @param client A non-owning pointer and must remain valid (normally the
   /// object implementing the Client interface will own the paint manager).
   /// @param is_always_opaque A flag passed to the device contexts that this
   /// class creates. Set this to true if your instance always draws an opaque
   /// image to the device. This is used as a hint to the browser that it does
   /// not need to do alpha blending, which speeds up painting. If you generate
   /// non-opqaue pixels or aren't sure, set this to false for more general
   /// blending.
   ///
-  /// If you set is_always_opaque, your alpha channel should always be set to
-  /// 0xFF or there may be painting artifacts. Being opaque will allow the
-  /// browser to do a memcpy rather than a blend to paint the plugin, and this
-  /// means your alpha values will get set on the page backing store. If these
-  /// values are incorrect, it could mess up future blending. If you aren't
-  /// sure, it is always correct to specify that it it not opaque.
+  /// If you set <code>is_always_opaque</code>, your alpha channel should
+  /// always be set to <code>0xFF</code> or there may be painting artifacts.
+  /// Being opaque will allow the browser to do a memcpy rather than a blend
+  /// to paint the plugin, and this means your alpha values will get set on the
+  /// page backing store. If these values are incorrect, it could mess up
+  /// future blending. If you aren't sure, it is always correct to specify that
+  /// it it not opaque.
   void Initialize(Instance* instance, Client* client, bool is_always_opaque);
 
   /// Setter function setting the max ratio of paint rect area to scroll rect
   /// area that we will tolerate before downgrading the scroll into a repaint.
   ///
   /// If the combined area of paint rects contained within the scroll
   /// rect grows too large, then we might as well just treat
   /// the scroll rect as a paint rect.
   ///
   /// @param[in] area The max ratio of paint rect area to scroll rect area that
@@ skipping 42 matching lines @@
   ///
   /// <strong>Note:</strong> If you call Flush on this device the paint manager
   /// will get very confused, don't do this!
   Graphics2D& graphics() { return graphics_; }
 
   /// Invalidate() invalidate the entire instance.
   void Invalidate();
 
   /// InvalidateRect() Invalidate the provided rect.
   ///
-  /// @param rect The <code>Rect</code> to be invalidated.
+  /// @param[in] rect The <code>Rect</code> to be invalidated.
   void InvalidateRect(const Rect& rect);
 
   /// ScrollRect() scrolls the provided <code>clip_rect</code> by the
   /// <code>amount</code> argument.
   ///
   /// @param clip_rect The clip rectangle to scroll.
   /// @param amount The amount to scroll <code>clip_rect</code>.
   void ScrollRect(const Rect& clip_rect, const Point& amount);
 
   /// GetEffectiveSize() returns the size of the graphics context for the
   /// next paint operation. This is the pending size if a resize is pending
   /// (the instance has called SetSize() but we haven't actually painted it
   /// yet), or the current size of no resize is pending.
   ///
-  /// @return The effetive size.
+  /// @return The effective size.
   Size GetEffectiveSize() const;
 
  private:
   // Disallow copy and assign (these are unimplemented).
   PaintManager(const PaintManager&);
   PaintManager& operator=(const PaintManager&);
 
   // Makes sure there is a callback that will trigger a paint at a later time.
   // This will be either a Flush callback telling us we're allowed to generate
   // more data, or, if there's no flush callback pending, a manual call back
@@ skipping 32 matching lines @@
   // When we get a resize, we don't bind right away (see SetSize). The
   // has_pending_resize_ tells us that we need to do a resize for the next
   // paint operation. When true, the new size is in pending_size_.
   bool has_pending_resize_;
   Size pending_size_;
 };
 
 }  // namespace pp
 
 #endif  // PPAPI_CPP_PAINT_MANAGER_H_