ChromeCanvas->gfx::Canvas

views/view.h

 // 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.
 
 #ifndef VIEWS_VIEW_H_
 #define VIEWS_VIEW_H_
 
 #include "build/build_config.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/gfx/rect.h"
 #include "base/scoped_ptr.h"
 #include "views/accelerator.h"
 #include "views/accessibility/accessibility_types.h"
 #include "views/background.h"
 #include "views/border.h"
 
 #if defined(OS_WIN)
 struct IDataObject;
 #endif  // defined(OS_WIN)
 
 namespace gfx {
+class Canvas;
 class Insets;
 class Path;
 }
 
-class ChromeCanvas;
 class OSExchangeData;
 class ViewAccessibilityWrapper;
 class ThemeProvider;
 
 namespace views {
 
 class Background;
 class Border;
 class FocusManager;
 class FocusTraversable;
@@ skipping 239 matching lines @@
   //
   // By default, right-to-left UI layout is enabled for the view and therefore
   // this function must be called (with false as the |enable| parameter) in
   // order to disable the right-to-left layout property for a specific instance
   // of the view. Disabling the right-to-left UI layout is necessary in case a
   // UI element will not appear correctly when mirrored.
   void EnableUIMirroringForRTLLanguages(bool enable) {
     ui_mirroring_is_enabled_for_rtl_languages_ = enable;
   }
 
-  // This method determines whether the ChromeCanvas object passed to
+  // This method determines whether the gfx::Canvas object passed to
   // View::Paint() needs to be transformed such that anything drawn on the
   // canvas object during View::Paint() is flipped horizontally.
   //
   // By default, this function returns false (which is the initial value of
   // |flip_canvas_on_paint_for_rtl_ui_|). View subclasses that need to paint on
-  // a flipped ChromeCanvas when the UI layout is right-to-left need to call
+  // a flipped gfx::Canvas when the UI layout is right-to-left need to call
   // EnableCanvasFlippingForRTLUI().
   bool FlipCanvasOnPaintForRTLUI() const {
     return flip_canvas_on_paint_for_rtl_ui_ ? UILayoutIsRightToLeft() : false;
   }
 
-  // Enables or disables flipping of the ChromeCanvas during View::Paint().
+  // Enables or disables flipping of the gfx::Canvas during View::Paint().
   // Note that if canvas flipping is enabled, the canvas will be flipped only
   // if the UI layout is right-to-left; that is, the canvas will be flipped
   // only if UILayoutIsRightToLeft() returns true.
   //
   // Enabling canvas flipping is useful for leaf views that draw a bitmap that
   // needs to be flipped horizontally when the UI layout is right-to-left
   // (views::Button, for example). This method is helpful for such classes
   // because their drawing logic stays the same and they can become agnostic to
   // the UI directionality.
   void EnableCanvasFlippingForRTLUI(bool enable) {
@@ skipping 47 matching lines @@
   // soon as possible.
   virtual void SchedulePaint(int x, int y, int w, int h);
 
   // Paint the receiving view. g is prepared such as it is in
   // receiver's coordinate system. g's state is restored after this
   // call so your implementation can change the graphics configuration
   //
   // Default implementation paints the background if it is defined
   //
   // Override this method when implementing a new control.
-  virtual void Paint(ChromeCanvas* canvas);
+  virtual void Paint(gfx::Canvas* canvas);
 
   // Paint the background if any. This method is called by Paint() and
   // should rarely be invoked directly.
-  virtual void PaintBackground(ChromeCanvas* canvas);
+  virtual void PaintBackground(gfx::Canvas* canvas);
 
   // Paint the border if any. This method is called by Paint() and
   // should rarely be invoked directly.
-  virtual void PaintBorder(ChromeCanvas* canvas);
+  virtual void PaintBorder(gfx::Canvas* canvas);
 
   // Paints the focus border (only if the view has the focus).
   // This method is called by Paint() and should rarely be invoked directly.
   // The default implementation paints a gray border around the view. Override
   // it for custom focus effects.
-  virtual void PaintFocusBorder(ChromeCanvas* canvas);
+  virtual void PaintFocusBorder(gfx::Canvas* canvas);
 
   // Paint this View immediately.
   virtual void PaintNow();
 
   // Tree functions
 
   // Add a child View.
   void AddChildView(View* v);
 
   // Adds a child View at the specified position.
@@ skipping 383 matching lines @@
   // Returns true if the mouse was dragged enough to start a drag operation.
   // delta_x and y are the distance the mouse was dragged.
   static bool ExceededDragThreshold(int delta_x, int delta_y);
 
   // This method is the main entry point to process paint for this
   // view and its children. This method is called by the painting
   // system. You should call this only if you want to draw a sub tree
   // inside a custom graphics.
   // To customize painting override either the Paint or PaintChildren method,
   // not this one.
-  virtual void ProcessPaint(ChromeCanvas* canvas);
+  virtual void ProcessPaint(gfx::Canvas* canvas);
 
   // Paint the View's child Views, in reverse order.
-  virtual void PaintChildren(ChromeCanvas* canvas);
+  virtual void PaintChildren(gfx::Canvas* canvas);
 
   // Sets the ContextMenuController. Setting this to non-null makes the View
   // process mouse events.
   void SetContextMenuController(ContextMenuController* menu_controller);
   ContextMenuController* GetContextMenuController() {
     return context_menu_controller_;
   }
 
   // Provides default implementation for context menu handling. The default
   // implementation calls the ShowContextMenu of the current
@@ skipping 389 matching lines @@
   scoped_ptr<ViewAccessibilityWrapper> accessibility_;
 #endif
 
   DragController* drag_controller_;
 
   // Indicates whether or not the view is going to be mirrored (that is, use a
   // right-to-left UI layout) if the locale's language is a right-to-left
   // language like Arabic or Hebrew.
   bool ui_mirroring_is_enabled_for_rtl_languages_;
 
-  // Indicates whether or not the ChromeCanvas object passed to View::Paint()
+  // Indicates whether or not the gfx::Canvas object passed to View::Paint()
   // is going to be flipped horizontally (using the appropriate transform) on
   // right-to-left locales for this View.
   bool flip_canvas_on_paint_for_rtl_ui_;
 
   DISALLOW_COPY_AND_ASSIGN(View);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_VIEW_H_