cc: Use skia::RefPtr in place of raw pointers and SkAutoTUnref.

cc/render_surface_filters.cc

 // Copyright 2012 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 "cc/render_surface_filters.h"
 
 #include "base/logging.h"
+#include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include "third_party/skia/include/effects/SkColorMatrixFilter.h"
 #include "third_party/skia/include/effects/SkMagnifierImageFilter.h"
 #include "third_party/skia/include/gpu/SkGpuDevice.h"
 #include "third_party/skia/include/gpu/SkGrPixelRef.h"
 #include "ui/gfx/size_f.h"
 #include <public/WebFilterOperation.h>
 #include <public/WebFilterOperations.h>
 #include <public/WebGraphicsContext3D.h>
@@ skipping 221 matching lines @@
     FilterBufferState(GrContext* grContext, const gfx::SizeF& size, unsigned textureId)
         : m_grContext(grContext)
         , m_currentTexture(0)
     {
         // Wrap the source texture in a Ganesh platform texture.
         GrPlatformTextureDesc platformTextureDescription;
         platformTextureDescription.fWidth = size.width();
         platformTextureDescription.fHeight = size.height();
         platformTextureDescription.fConfig = kSkia8888_GrPixelConfig;
         platformTextureDescription.fTextureHandle = textureId;
-        SkAutoTUnref<GrTexture> texture(grContext->createPlatformTexture(platformTextureDescription));
+        skia::RefPtr<GrTexture> texture = skia::AdoptRef(grContext->createPlatformTexture(platformTextureDescription));
         // Place the platform texture inside an SkBitmap.
         m_source.setConfig(SkBitmap::kARGB_8888_Config, size.width(), size.height());
-        m_source.setPixelRef(new SkGrPixelRef(texture.get()))->unref();
+        skia::RefPtr<SkGrPixelRef> pixelRef = skia::AdoptRef(new SkGrPixelRef(texture.get()));
+        m_source.setPixelRef(pixelRef.get());
     }
 
     ~FilterBufferState() { }
 
     bool init(int filterCount)
     {
         int scratchCount = std::min(2, filterCount);
         GrTextureDesc desc;
         desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
         desc.fSampleCnt = 0;
         desc.fWidth = m_source.width();
         desc.fHeight = m_source.height();
         desc.fConfig = kSkia8888_GrPixelConfig;
         for (int i = 0; i < scratchCount; ++i) {
             GrAutoScratchTexture scratchTexture(m_grContext, desc, GrContext::kExact_ScratchTexMatch);
-            m_scratchTextures[i].reset(scratchTexture.detach());
-            if (!m_scratchTextures[i].get())
+            m_scratchTextures[i] = skia::AdoptRef(scratchTexture.detach());
+            if (!m_scratchTextures[i])
                 return false;
         }
         return true;
     }
 
     SkCanvas* canvas()
     {
         if (!m_canvas.get())
             createCanvas();
         return m_canvas.get();
     }
 
     const SkBitmap& source() { return m_source; }
 
     void swap()
     {
         m_canvas->flush();
-        m_canvas.reset(0);
-        m_device.reset(0);
+        m_canvas.clear();
+        m_device.clear();
 
-        m_source.setPixelRef(new SkGrPixelRef(m_scratchTextures[m_currentTexture].get()))->unref();
+        skia::RefPtr<SkGrPixelRef> pixelRef = skia::AdoptRef(new SkGrPixelRef(m_scratchTextures[m_currentTexture].get()));
+        m_source.setPixelRef(pixelRef.get());
         m_currentTexture = 1 - m_currentTexture;
     }
 
 private:
     void createCanvas()
     {
         DCHECK(m_scratchTextures[m_currentTexture].get());
-        m_device.reset(new SkGpuDevice(m_grContext, m_scratchTextures[m_currentTexture].get()));
-        m_canvas.reset(new SkCanvas(m_device.get()));
+        m_device = skia::AdoptRef(new SkGpuDevice(m_grContext, m_scratchTextures[m_currentTexture].get()));
+        m_canvas = skia::AdoptRef(new SkCanvas(m_device.get()));
         m_canvas->clear(0x0);
     }
 
     GrContext* m_grContext;
     SkBitmap m_source;
-    SkAutoTUnref<GrTexture> m_scratchTextures[2];
+    skia::RefPtr<GrTexture> m_scratchTextures[2];
     int m_currentTexture;
-    SkAutoTUnref<SkGpuDevice> m_device;
-    SkAutoTUnref<SkCanvas> m_canvas;
+    skia::RefPtr<SkGpuDevice> m_device;
+    skia::RefPtr<SkCanvas> m_canvas;
 };
 
 }  // namespace
 
 WebKit::WebFilterOperations RenderSurfaceFilters::optimize(const WebKit::WebFilterOperations& filters)
 {
     WebKit::WebFilterOperations newList;
 
     SkScalar accumulatedColorMatrix[20];
     bool haveAccumulatedColorMatrix = false;
@@ skipping 55 matching lines @@
     FilterBufferState state(grContext, size, textureId);
     if (!state.init(optimizedFilters.size()))
         return SkBitmap();
 
     for (unsigned i = 0; i < optimizedFilters.size(); ++i) {
         const WebKit::WebFilterOperation& op = optimizedFilters.at(i);
         SkCanvas* canvas = state.canvas();
         switch (op.type()) {
         case WebKit::WebFilterOperation::FilterTypeColorMatrix: {
             SkPaint paint;
-            paint.setColorFilter(new SkColorMatrixFilter(op.matrix()))->unref();
+            skia::RefPtr<SkColorMatrixFilter> filter = skia::AdoptRef(new SkColorMatrixFilter(op.matrix()));
+            paint.setColorFilter(filter.get());
             canvas->drawBitmap(state.source(), 0, 0, &paint);
             break;
         }
         case WebKit::WebFilterOperation::FilterTypeBlur: {
             float stdDeviation = op.amount();
-            SkAutoTUnref<SkImageFilter> filter(new SkBlurImageFilter(stdDeviation, stdDeviation));
+            skia::RefPtr<SkImageFilter> filter = skia::AdoptRef(new SkBlurImageFilter(stdDeviation, stdDeviation));
             SkPaint paint;
             paint.setImageFilter(filter.get());
             canvas->drawSprite(state.source(), 0, 0, &paint);
             break;
         }
         case WebKit::WebFilterOperation::FilterTypeDropShadow: {
-            SkAutoTUnref<SkImageFilter> blurFilter(new SkBlurImageFilter(op.amount(), op.amount()));
-            SkAutoTUnref<SkColorFilter> colorFilter(SkColorFilter::CreateModeFilter(op.dropShadowColor(), SkXfermode::kSrcIn_Mode));
+            skia::RefPtr<SkImageFilter> blurFilter = skia::AdoptRef(new SkBlurImageFilter(op.amount(), op.amount()));
+            skia::RefPtr<SkColorFilter> colorFilter = skia::AdoptRef(SkColorFilter::CreateModeFilter(op.dropShadowColor(), SkXfermode::kSrcIn_Mode));
             SkPaint paint;
             paint.setImageFilter(blurFilter.get());
             paint.setColorFilter(colorFilter.get());
             paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
             canvas->saveLayer(0, &paint);
             canvas->drawBitmap(state.source(), op.dropShadowOffset().x, -op.dropShadowOffset().y);
             canvas->restore();
             canvas->drawBitmap(state.source(), 0, 0);
             break;
         }
         case WebKit::WebFilterOperation::FilterTypeZoom: {
             SkPaint paint;
-            SkAutoTUnref<SkImageFilter> zoomFilter(
+            skia::RefPtr<SkImageFilter> zoomFilter = skia::AdoptRef(
                 new SkMagnifierImageFilter(
                     SkRect::MakeXYWH(op.zoomRect().x,
                                      op.zoomRect().y,
                                      op.zoomRect().width,
                                      op.zoomRect().height),
                     op.amount()));
             paint.setImageFilter(zoomFilter.get());
             canvas->saveLayer(0, &paint);
             canvas->drawBitmap(state.source(), 0, 0);
             canvas->restore();
@@ skipping 10 matching lines @@
             NOTREACHED();
             break;
         }
         state.swap();
     }
     context3D->flush();
     return state.source();
 }
 
 }  // namespace cc