ChromeCanvas->gfx::Canvas

chrome/browser/views/autocomplete/autocomplete_popup_contents_view.cc

 // Copyright (c) 2009 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 "chrome/browser/views/autocomplete/autocomplete_popup_contents_view.h"
 
 #include <objidl.h>
 #include <commctrl.h>
 #include <dwmapi.h>
 
-#include "app/gfx/chrome_canvas.h"
+#include "app/gfx/canvas.h"
 #include "app/gfx/color_utils.h"
 #include "app/gfx/insets.h"
 #include "app/gfx/path.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "app/win_util.h"
 #include "chrome/browser/autocomplete/autocomplete_edit_view_win.h"
 #include "chrome/browser/autocomplete/autocomplete_popup_model.h"
 #include "chrome/browser/views/autocomplete/autocomplete_popup_win.h"
 #include "grit/generated_resources.h"
@@ skipping 42 matching lines @@
 static const int kEditFontAdjust = -1;
 
 class AutocompleteResultView : public views::View {
  public:
   AutocompleteResultView(AutocompleteResultViewModel* model,
                          int model_index,
                          const gfx::Font& font);
   virtual ~AutocompleteResultView();
 
   // Overridden from views::View:
-  virtual void Paint(ChromeCanvas* canvas);
+  virtual void Paint(gfx::Canvas* canvas);
   virtual void Layout();
   virtual gfx::Size GetPreferredSize();
   virtual void OnMouseEntered(const views::MouseEvent& event);
   virtual void OnMouseMoved(const views::MouseEvent& event);
   virtual void OnMouseExited(const views::MouseEvent& event);
   virtual bool OnMousePressed(const views::MouseEvent& event);
   virtual void OnMouseReleased(const views::MouseEvent& event, bool canceled);
   virtual bool OnMouseDragged(const views::MouseEvent& event);
 
  private:
   // Get colors for row backgrounds and text for different row states.
   SkColor GetBackgroundColor() const;
   SkColor GetTextColor() const;
 
   SkBitmap* GetIcon() const;
 
   // Draws the specified |text| into the canvas, using highlighting provided by
   // |classifications|. If |force_dim| is true, ACMatchClassification::DIM is
   // added to all of the classifications. Returns the x position to the right
   // of the string.
-  int DrawString(ChromeCanvas* canvas,
-                  const std::wstring& text,
-                  const ACMatchClassifications& classifications,
-                  bool force_dim,
-                  int x,
-                  int y);
+  int DrawString(gfx::Canvas* canvas,
+                 const std::wstring& text,
+                 const ACMatchClassifications& classifications,
+                 bool force_dim,
+                 int x,
+                 int y);
 
   // Draws an individual sub-fragment with the specified style. Returns the x
   // position to the right of the fragment.
-  int DrawStringFragment(ChromeCanvas* canvas,
+  int DrawStringFragment(gfx::Canvas* canvas,
                          const std::wstring& text,
                          int style,
                          int x,
                          int y);
 
   // Gets the font and text color for a fragment with the specified style.
   gfx::Font GetFragmentFont(int style) const;
   SkColor GetFragmentTextColor(int style) const;
 
   // This row's model and model index.
@@ skipping 162 matching lines @@
       model_index_(model_index),
       hot_(false),
       font_(font),
       mirroring_context_(new MirroringContext()) {
   InitClass();
 }
 
 AutocompleteResultView::~AutocompleteResultView() {
 }
 
-void AutocompleteResultView::Paint(ChromeCanvas* canvas) {
+void AutocompleteResultView::Paint(gfx::Canvas* canvas) {
   canvas->FillRectInt(GetBackgroundColor(), 0, 0, width(), height());
 
   int x = MirroredLeftPointForRect(icon_bounds_);
 
   // Paint the icon.
   canvas->DrawBitmapInt(*GetIcon(), x, icon_bounds_.y());
 
   const AutocompleteMatch& match = model_->GetMatchAtIndex(model_index_);
 
   // Paint the text.
@@ skipping 116 matching lines @@
     case AutocompleteMatch::OPEN_HISTORY_PAGE:
       return selected ? icon_more_selected_ : icon_more_;
     default:
       NOTREACHED();
       break;
   }
   return NULL;
 }
 
 int AutocompleteResultView::DrawString(
-    ChromeCanvas* canvas,
+    gfx::Canvas* canvas,
     const std::wstring& text,
     const ACMatchClassifications& classifications,
     bool force_dim,
     int x,
     int y) {
   if (!text.length())
     return x;
 
   // Initialize a bidirectional line iterator of ICU and split the text into
   // visual runs. (A visual run is consecutive characters which have the same
@@ skipping 52 matching lines @@
         x += DrawStringFragment(canvas,
                                 text.substr(text_start, text_end - text_start),
                                 style, x, y);
       }
     }
   }
   return x;
 }
 
 int AutocompleteResultView::DrawStringFragment(
-    ChromeCanvas* canvas,
+    gfx::Canvas* canvas,
     const std::wstring& text,
     int style,
     int x,
     int y) {
   gfx::Font display_font = GetFragmentFont(style);
   // Clamp text width to the available width within the popup so we elide if
   // necessary.
   int string_width = std::min(display_font.GetStringWidth(text),
                               width() - kRowRightPadding - x);
   int string_left = mirroring_context_->GetLeft(x, x + string_width);
@@ skipping 48 matching lines @@
   }
   virtual ~PopupBorder() {}
 
   // Returns the border radius of the edge of the popup.
   static int GetBorderRadius() {
     InitClass();
     return dropshadow_topleft_->width() - dropshadow_left_->width() - 1;
   }
 
   // Overridden from views::Border:
-  virtual void Paint(const views::View& view, ChromeCanvas* canvas) const;
+  virtual void Paint(const views::View& view, gfx::Canvas* canvas) const;
   virtual void GetInsets(gfx::Insets* insets) const;
 
  private:
   // Border graphics.
   static SkBitmap* dropshadow_left_;
   static SkBitmap* dropshadow_topleft_;
   static SkBitmap* dropshadow_top_;
   static SkBitmap* dropshadow_topright_;
   static SkBitmap* dropshadow_right_;
   static SkBitmap* dropshadow_bottomright_;
   static SkBitmap* dropshadow_bottom_;
   static SkBitmap* dropshadow_bottomleft_;
 
   static void InitClass();
 
   DISALLOW_COPY_AND_ASSIGN(PopupBorder);
 };
 
 // static
 SkBitmap* PopupBorder::dropshadow_left_ = NULL;
 SkBitmap* PopupBorder::dropshadow_topleft_ = NULL;
 SkBitmap* PopupBorder::dropshadow_top_ = NULL;
 SkBitmap* PopupBorder::dropshadow_topright_ = NULL;
 SkBitmap* PopupBorder::dropshadow_right_ = NULL;
 SkBitmap* PopupBorder::dropshadow_bottomright_ = NULL;
 SkBitmap* PopupBorder::dropshadow_bottom_ = NULL;
 SkBitmap* PopupBorder::dropshadow_bottomleft_ = NULL;
 
-void PopupBorder::Paint(const views::View& view, ChromeCanvas* canvas) const {
+void PopupBorder::Paint(const views::View& view, gfx::Canvas* canvas) const {
   int ds_tl_width = dropshadow_topleft_->width();
   int ds_tl_height = dropshadow_topleft_->height();
   int ds_tr_width = dropshadow_topright_->width();
   int ds_tr_height = dropshadow_topright_->height();
   int ds_br_width = dropshadow_bottomright_->width();
   int ds_br_height = dropshadow_bottomright_->height();
   int ds_bl_width = dropshadow_bottomleft_->width();
   int ds_bl_height = dropshadow_bottomleft_->height();
 
   canvas->DrawBitmapInt(*dropshadow_topleft_, 0, 0);
@@ skipping 154 matching lines @@
 }
 
 void AutocompletePopupContentsView::SetSelectedLine(size_t index,
                                                     bool revert_to_default) {
   model_->SetSelectedLine(index, revert_to_default);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AutocompletePopupContentsView, views::View overrides:
 
-void AutocompletePopupContentsView::PaintChildren(ChromeCanvas* canvas) {
+void AutocompletePopupContentsView::PaintChildren(gfx::Canvas* canvas) {
   // We paint our children in an unconventional way.
   //
   // Because the border of this view creates an anti-aliased round-rect region
   // for the contents, we need to render our rectangular result child views into
   // this round rect region. We can't use a simple clip because clipping is
   // 1-bit and we get nasty jagged edges.
   //
   // Instead, we paint all our children into a second canvas and use that as a
   // shader to fill a path representing the round-rect clipping region. This
   // yields a nice anti-aliased edge.
-  ChromeCanvas contents_canvas(width(), height(), true);
+  gfx::Canvas contents_canvas(width(), height(), true);
   contents_canvas.FillRectInt(kBackgroundColor, 0, 0, width(), height());
   View::PaintChildren(&contents_canvas);
   // We want the contents background to be slightly transparent so we can see
   // the blurry glass effect on DWM systems behind. We do this _after_ we paint
   // the children since they paint text, and GDI will reset this alpha data if
   // we paint text after this call.
   MakeCanvasTransparent(&contents_canvas);
 
   // Now paint the contents of the contents canvas into the actual canvas.
   SkPaint paint;
@@ skipping 66 matching lines @@
 
   gfx::Path contents_path;
   MakeContentsPath(&contents_path, contents_rect);
   ScopedGDIObject<HRGN> popup_region;
   popup_region.Set(contents_path.CreateHRGN());
   bb.hRgnBlur = popup_region.Get();
   DwmEnableBlurBehindWindow(GetWidget()->GetNativeView(), &bb);
 }
 
 void AutocompletePopupContentsView::MakeCanvasTransparent(
-    ChromeCanvas* canvas) {
+    gfx::Canvas* canvas) {
   // Allow the window blur effect to show through the popup background.
   SkPaint paint;
   SkColor transparency = win_util::ShouldUseVistaFrame() ?
       kGlassPopupTransparency : kOpaquePopupTransparency;
   paint.setColor(SkColorSetARGB(transparency, 255, 255, 255));
   paint.setPorterDuffXfermode(SkPorterDuff::kDstIn_Mode);
   paint.setStyle(SkPaint::kFill_Style);
   canvas->FillRectInt(0, 0, canvas->getDevice()->width(),
                       canvas->getDevice()->height(), paint);
 }