Include base/win/scoped_comptr.h instead of base/scoped_comptr_win.h.

ui/gfx/canvas_direct2d.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 "ui/gfx/canvas_direct2d.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "ui/gfx/brush.h"
 #include "ui/gfx/rect.h"
 
@@ skipping 45 matching lines @@
   bitmap.unlockPixels();
   return d2d1_bitmap;
 }
 
 // Creates a Direct2D bitmap brush from the contents of a SkBitmap. The caller
 // is responsible for releasing this object.
 ID2D1Brush* CreateD2D1BrushFromSkBitmap(ID2D1RenderTarget* render_target,
                                         const SkBitmap& bitmap,
                                         D2D1_EXTEND_MODE extend_mode_x,
                                         D2D1_EXTEND_MODE extend_mode_y) {
-  ScopedComPtr<ID2D1Bitmap> d2d1_bitmap(
+  base::win::ScopedComPtr<ID2D1Bitmap> d2d1_bitmap(
       CreateD2D1BitmapFromSkBitmap(render_target, bitmap));
 
   ID2D1BitmapBrush* brush = NULL;
   render_target->CreateBitmapBrush(
       d2d1_bitmap,
       D2D1::BitmapBrushProperties(extend_mode_x, extend_mode_y),
       D2D1::BrushProperties(),
       &brush);
   return brush;
 }
 
 // A platform wrapper for a Direct2D brush that makes sure the underlying
 // ID2D1Brush COM object is released when this object is destroyed.
 class Direct2DBrush : public gfx::Brush {
  public:
   explicit Direct2DBrush(ID2D1Brush* brush) : brush_(brush) {
   }
 
   ID2D1Brush* brush() const { return brush_.get(); }
 
  private:
-  ScopedComPtr<ID2D1Brush> brush_;
+  base::win::ScopedComPtr<ID2D1Brush> brush_;
 
   DISALLOW_COPY_AND_ASSIGN(Direct2DBrush);
 };
 
 
 }  // namespace
 
 namespace gfx {
 
 // static
@@ skipping 98 matching lines @@
   rt_->GetTransform(&raw);
   D2D1::Matrix3x2F transform(raw._11, raw._12, raw._21, raw._22, raw._31,
                              raw._32);
   transform = D2D1::Matrix3x2F::Scale(static_cast<float>(x),
                                       static_cast<float>(y)) * transform;
   rt_->SetTransform(transform);
 }
 
 void CanvasDirect2D::FillRectInt(const SkColor& color,
                                  int x, int y, int w, int h) {
-  ScopedComPtr<ID2D1SolidColorBrush> solid_brush;
+  base::win::ScopedComPtr<ID2D1SolidColorBrush> solid_brush;
   rt_->CreateSolidColorBrush(SkColorToColorF(color), solid_brush.Receive());
   rt_->FillRectangle(RectToRectF(x, y, w, h), solid_brush);
 }
 
 void CanvasDirect2D::FillRectInt(const SkColor& color,
                                  int x, int y, int w, int h,
                                  SkXfermode::Mode mode) {
   NOTIMPLEMENTED();
 }
 
 void CanvasDirect2D::FillRectInt(const gfx::Brush* brush,
                                  int x, int y, int w, int h) {
   const Direct2DBrush* d2d_brush = static_cast<const Direct2DBrush*>(brush);
   rt_->FillRectangle(RectToRectF(x, y, w, h), d2d_brush->brush());
 }
 
 void CanvasDirect2D::DrawRectInt(const SkColor& color,
                                  int x, int y, int w, int h) {
-  ScopedComPtr<ID2D1SolidColorBrush> solid_brush;
+  base::win::ScopedComPtr<ID2D1SolidColorBrush> solid_brush;
   rt_->CreateSolidColorBrush(SkColorToColorF(color), solid_brush.Receive());
   rt_->DrawRectangle(RectToRectF(x, y, w, h), solid_brush);
 }
 
 void CanvasDirect2D::DrawRectInt(const SkColor& color,
                                  int x, int y, int w, int h,
                                  SkXfermode::Mode mode) {
   NOTIMPLEMENTED();
 }
 
 void CanvasDirect2D::DrawRectInt(int x, int y, int w, int h,
                                  const SkPaint& paint) {
   NOTIMPLEMENTED();
 }
 
 void CanvasDirect2D::DrawLineInt(const SkColor& color,
                                  int x1, int y1,
                                  int x2, int y2) {
-  ScopedComPtr<ID2D1SolidColorBrush> solid_brush;
+  base::win::ScopedComPtr<ID2D1SolidColorBrush> solid_brush;
   rt_->CreateSolidColorBrush(SkColorToColorF(color), solid_brush.Receive());
   rt_->DrawLine(PointToPoint2F(x1, y1), PointToPoint2F(x2, y2), solid_brush);
 }
 
 void CanvasDirect2D::DrawBitmapInt(const SkBitmap& bitmap, int x, int y) {
-  ScopedComPtr<ID2D1Bitmap> d2d1_bitmap(
+  base::win::ScopedComPtr<ID2D1Bitmap> d2d1_bitmap(
       CreateD2D1BitmapFromSkBitmap(rt_, bitmap));
   rt_->DrawBitmap(d2d1_bitmap,
                   RectToRectF(x, y, bitmap.width(), bitmap.height()),
                   1.0f,
                   D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR,
                   RectToRectF(0, 0, bitmap.width(), bitmap.height()));
 }
 
 void CanvasDirect2D::DrawBitmapInt(const SkBitmap& bitmap,
                                    int x, int y,
                                    const SkPaint& paint) {
   NOTIMPLEMENTED();
 }
 
 void CanvasDirect2D::DrawBitmapInt(const SkBitmap& bitmap,
                                    int src_x, int src_y, int src_w, int src_h,
                                    int dest_x, int dest_y,
                                    int dest_w, int dest_h,
                                    bool filter) {
-  ScopedComPtr<ID2D1Bitmap> d2d1_bitmap(
+  base::win::ScopedComPtr<ID2D1Bitmap> d2d1_bitmap(
       CreateD2D1BitmapFromSkBitmap(rt_, bitmap));
   rt_->DrawBitmap(d2d1_bitmap,
                   RectToRectF(dest_x, dest_y, dest_w, dest_h),
                   1.0f,
                   FilterToInterpolationMode(filter),
                   RectToRectF(src_x, src_y, src_w, src_h));
 }
 
 void CanvasDirect2D::DrawBitmapInt(const SkBitmap& bitmap,
                                    int src_x, int src_y, int src_w, int src_h,
@@ skipping 25 matching lines @@
                                    int flags) {
   NOTIMPLEMENTED();
 }
 
 void CanvasDirect2D::DrawFocusRect(int x, int y, int width, int height) {
   NOTIMPLEMENTED();
 }
 
 void CanvasDirect2D::TileImageInt(const SkBitmap& bitmap,
                                   int x, int y, int w, int h) {
-  ScopedComPtr<ID2D1Brush> brush(
+  base::win::ScopedComPtr<ID2D1Brush> brush(
       CreateD2D1BrushFromSkBitmap(rt_, bitmap, D2D1_EXTEND_MODE_WRAP,
                                   D2D1_EXTEND_MODE_WRAP));
   rt_->FillRectangle(RectToRectF(x, y, w, h), brush);
 }
 
 void CanvasDirect2D::TileImageInt(const SkBitmap& bitmap,
                                   int src_x, int src_y,
                                   int dest_x, int dest_y, int w, int h) {
   NOTIMPLEMENTED();
 }
@@ skipping 34 matching lines @@
 // CanvasDirect2D, private:
 
 void CanvasDirect2D::SaveInternal(ID2D1Layer* layer) {
   if (!drawing_state_block_)
     GetD2D1Factory()->CreateDrawingStateBlock(drawing_state_block_.Receive());
   rt_->SaveDrawingState(drawing_state_block_.get());
   state_.push(RenderState(layer));
 }
 
 }  // namespace gfx