Cleanup: Remove ScopedGenericObj usage in media/.

media/webm/chromeos/webm_encoder.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 "media/webm/chromeos/webm_encoder.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/logging.h"
-#include "base/memory/scoped_generic_obj.h"
+#include "base/memory/scoped_ptr.h"
 #include "libyuv/convert.h"
 #include "libyuv/video_common.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 extern "C" {
 // Getting the right degree of C compatibility has been a constant struggle.
 // - Stroustrup, C++ Report, 12(7), July/August 2000.
 #define private priv
 #include "third_party/libvpx/source/libvpx/libmkv/EbmlIDs.h"
 #include "third_party/libvpx/source/libvpx/libmkv/EbmlWriter.h"
 #undef private
 }
 
 // Number of encoder threads to use.
 static const int kNumEncoderThreads = 2;
 
 // Need a fixed size serializer for the track ID. libmkv provides a 64 bit
 // one, but not a 32 bit one.
 static void Ebml_SerializeUnsigned32(EbmlGlobal* ebml,
                                      unsigned long class_id,
                                      uint64_t value) {
   uint8 size_serialized = 4 | 0x80;
   Ebml_WriteID(ebml, class_id);
   Ebml_Serialize(ebml, &size_serialized, sizeof(size_serialized), 1);
   Ebml_Serialize(ebml, &value, sizeof(value), 4);
 }
 
 // Wrapper functor for vpx_codec_destroy().
-class VpxCodecDestroyHelper {
- public:
+struct VpxCodecDeleter {
   void operator()(vpx_codec_ctx_t* codec) {
     vpx_codec_destroy(codec);
   }
 };
 
 // Wrapper functor for vpx_img_free().
-class VpxImgFreeHelper {
- public:
+struct VpxImgDeleter {
   void operator()(vpx_image_t* image) {
     vpx_img_free(image);
   }
 };
 
 namespace media {
 
 namespace chromeos {
 
 WebmEncoder::WebmEncoder(const base::FilePath& output_path,
@@ skipping 23 matching lines @@
   height_ = sprite.width();
   fps_.num = fps_n;
   fps_.den = fps_d;
 
   // Sprite is tiled vertically.
   frame_count_ = sprite.height() / width_;
 
   vpx_image_t image;
   vpx_img_alloc(&image, VPX_IMG_FMT_I420, width_, height_, 16);
   // Ensure that image is freed after return.
-  ScopedGenericObj<vpx_image_t*, VpxImgFreeHelper> image_ptr(&image);
+  scoped_ptr<vpx_image_t, VpxImgDeleter> image_ptr(&image);
 
   const vpx_codec_iface_t* codec_iface = vpx_codec_vp8_cx();
   DCHECK(codec_iface);
   vpx_codec_err_t ret = vpx_codec_enc_config_default(codec_iface, &config_, 0);
   DCHECK_EQ(VPX_CODEC_OK, ret);
 
   config_.rc_target_bitrate = bitrate_;
   config_.g_w = width_;
   config_.g_h = height_;
   config_.g_pass = VPX_RC_ONE_PASS;
   config_.g_profile = 0;          // Default profile.
   config_.g_threads = kNumEncoderThreads;
   config_.rc_min_quantizer = 0;
   config_.rc_max_quantizer = 63;  // Maximum possible range.
   config_.g_timebase.num = fps_.den;
   config_.g_timebase.den = fps_.num;
   config_.kf_mode = VPX_KF_AUTO;  // Auto key frames.
 
   vpx_codec_ctx_t codec;
   ret = vpx_codec_enc_init(&codec, codec_iface, &config_, 0);
   if (ret != VPX_CODEC_OK)
     return false;
   // Ensure that codec context is freed after return.
-  ScopedGenericObj<vpx_codec_ctx_t*, VpxCodecDestroyHelper> codec_ptr(&codec);
+  scoped_ptr<vpx_codec_ctx_t, VpxCodecDeleter> codec_ptr(&codec);
 
   SkAutoLockPixels lock_sprite(sprite);
 
   const uint8* src = reinterpret_cast<const uint8*>(sprite.getAddr32(0, 0));
   size_t src_frame_size = sprite.getSize();
   int crop_y = 0;
 
   if (!WriteWebmHeader())
     return false;
 
@@ skipping 187 matching lines @@
     case 8:
       return EbmlSerializeHelper(static_cast<const int64_t*>(buffer), len);
     default:
       NOTREACHED() << "Invalid EbmlSerialize length: " << len;
   }
 }
 
 }  // namespace chromeos
 
 }  // namespace media