Replace many skia::RefPtr with sk_sp<> in cc/

content/common/cc_messages.cc

 // Copyright (c) 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 "content/common/cc_messages.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/numerics/safe_conversions.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/filter_operations.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/largest_draw_quad.h"
 #include "cc/quads/render_pass_id.h"
 #include "content/public/common/common_param_traits.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkFlattenableSerialization.h"
+#include "third_party/skia/include/core/SkImageFilter.h"
+#include "third_party/skia/include/core/SkRefCnt.h"
 
 namespace IPC {
 
 void ParamTraits<cc::FilterOperation>::Write(base::Pickle* m,
                                              const param_type& p) {
   WriteParam(m, p.type());
   switch (p.type()) {
     case cc::FilterOperation::GRAYSCALE:
     case cc::FilterOperation::SEPIA:
     case cc::FilterOperation::SATURATE:
@@ skipping 85 matching lines @@
       if (ReadParam(m, iter, &amount) &&
           ReadParam(m, iter, &zoom_inset) &&
           amount >= 0.f &&
           zoom_inset >= 0) {
         r->set_amount(amount);
         r->set_zoom_inset(zoom_inset);
         success = true;
       }
       break;
     case cc::FilterOperation::REFERENCE: {
-      skia::RefPtr<SkImageFilter> filter;
+      sk_sp<SkImageFilter> filter;
       if (!ReadParam(m, iter, &filter)) {
         success = false;
         break;
       }
       r->set_image_filter(filter);

[f(malita), 2016/04/21 15:45:47]

I can't quite tell what param type set_image_filter expects, but if possible we
should move(filter) here.

[tomhudson, 2016/04/25 20:20:51]

Yes, cc::FilterOperation() takes sk_sp<>, so we can std::move() here. Done.

       success = true;
       break;
     }
     case cc::FilterOperation::ALPHA_THRESHOLD:
       break;
   }
   return success;
 }
 
 void ParamTraits<cc::FilterOperation>::Log(
@@ skipping 72 matching lines @@
     const param_type& p, std::string* l) {
   l->append("(");
   for (std::size_t i = 0; i < p.size(); ++i) {
     if (i)
       l->append(", ");
     LogParam(p.at(i), l);
   }
   l->append(")");
 }
 
-void ParamTraits<skia::RefPtr<SkImageFilter>>::Write(base::Pickle* m,
-                                                     const param_type& p) {
+void ParamTraits<sk_sp<SkImageFilter>>::Write(base::Pickle* m,
+                                              const param_type& p) {
   SkImageFilter* filter = p.get();
   if (filter) {
     sk_sp<SkData> data(SkValidatingSerializeFlattenable(filter));
     m->WriteData(static_cast<const char*>(data->data()), data->size());
   } else {
     m->WriteData(0, 0);
   }
 }
 
-bool ParamTraits<skia::RefPtr<SkImageFilter>>::Read(const base::Pickle* m,
-                                                    base::PickleIterator* iter,
-                                                    param_type* r) {
+bool ParamTraits<sk_sp<SkImageFilter>>::Read(const base::Pickle* m,
+                                             base::PickleIterator* iter,
+                                             param_type* r) {
   const char* data = 0;
   int length = 0;
   if (!iter->ReadData(&data, &length))
     return false;
   if (length > 0) {
     SkFlattenable* flattenable = SkValidatingDeserializeFlattenable(
         data, length, SkImageFilter::GetFlattenableType());
-    *r = skia::AdoptRef(static_cast<SkImageFilter*>(flattenable));
+    *r = sk_sp<SkImageFilter>(static_cast<SkImageFilter*>(flattenable));
   } else {
-    r->clear();
+    r->reset();
   }
   return true;
 }
 
-void ParamTraits<skia::RefPtr<SkImageFilter> >::Log(
+void ParamTraits<sk_sp<SkImageFilter> >::Log(
     const param_type& p, std::string* l) {
   l->append("(");
   LogParam(p.get() ? p->countInputs() : 0, l);
   l->append(")");
 }
 
 void ParamTraits<cc::RenderPass>::Write(base::Pickle* m, const param_type& p) {
   WriteParam(m, p.id);
   WriteParam(m, p.output_rect);
   WriteParam(m, p.damage_rect);
@@ skipping 542 matching lines @@
   l->append("TextureDrawQuad::OverlayResources([");
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     LogParam(p.size_in_pixels[i], l);
     if (i < (cc::DrawQuad::Resources::kMaxResourceIdCount - 1))
       l->append(", ");
   }
   l->append("])");
 }
 
 }  // namespace IPC