Remove reinterpret_cast on JSONValueConverter

base/json/json_value_converter.h

 // 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.
 
 #ifndef BASE_JSON_JSON_VALUE_CONVERTER_H_
 #define BASE_JSON_JSON_VALUE_CONVERTER_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
-#include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_piece.h"
 #include "base/values.h"
 
 // JSONValueConverter converts a JSON value into a C++ struct in a
@@ skipping 62 matching lines @@
 //     }
 //   };
 
 namespace base {
 
 template <typename StructType>
 class JSONValueConverter;
 
 namespace internal {
 
+template<typename StructType>
 class FieldConverterBase {
  public:
-  BASE_EXPORT explicit FieldConverterBase(const std::string& path);
-  BASE_EXPORT virtual ~FieldConverterBase();
-  virtual bool ConvertField(const base::Value& value, void* obj) const = 0;
+  explicit FieldConverterBase(const std::string& path) : field_path_(path) {}
+  virtual ~FieldConverterBase() {}
+  virtual bool ConvertField(const base::Value& value, StructType* obj)
+      const = 0;
   const std::string& field_path() const { return field_path_; }
 
  private:
   std::string field_path_;
   DISALLOW_COPY_AND_ASSIGN(FieldConverterBase);
 };
 
 template <typename FieldType>
 class ValueConverter {
  public:
   virtual ~ValueConverter() {}
   virtual bool Convert(const base::Value& value, FieldType* field) const = 0;
 };
 
 template <typename StructType, typename FieldType>
-class FieldConverter : public FieldConverterBase {
+class FieldConverter : public FieldConverterBase<StructType> {
  public:
   explicit FieldConverter(const std::string& path,
                           FieldType StructType::* field,
                           ValueConverter<FieldType>* converter)
-      : FieldConverterBase(path),
+      : FieldConverterBase<StructType>(path),
         field_pointer_(field),
         value_converter_(converter) {
   }
 
   virtual bool ConvertField(
-      const base::Value& value, void* obj) const OVERRIDE {
-    StructType* dst = reinterpret_cast<StructType*>(obj);
+      const base::Value& value, StructType* dst) const OVERRIDE {
     return value_converter_->Convert(value, &(dst->*field_pointer_));
   }
 
  private:
   FieldType StructType::* field_pointer_;
   scoped_ptr<ValueConverter<FieldType> > value_converter_;
   DISALLOW_COPY_AND_ASSIGN(FieldConverter);
 };
 
 template <typename FieldType>
@@ skipping 278 matching lines @@
             field,
             new internal::RepeatedMessageConverter<NestedType>));
   }
 
   bool Convert(const base::Value& value, StructType* output) const {
     const DictionaryValue* dictionary_value = NULL;
     if (!value.GetAsDictionary(&dictionary_value))
       return false;
 
     for(size_t i = 0; i < fields_.size(); ++i) {
-      const internal::FieldConverterBase* field_converter = fields_[i];
+      const internal::FieldConverterBase<StructType>* field_converter =
+          fields_[i];
       base::Value* field = NULL;
       if (dictionary_value->Get(field_converter->field_path(), &field)) {
         if (!field_converter->ConvertField(*field, output)) {
           DVLOG(1) << "failure at field " << field_converter->field_path();
           return false;
         }
       }
     }
     return true;
   }
 
  private:
-  ScopedVector<internal::FieldConverterBase> fields_;
+  ScopedVector<internal::FieldConverterBase<StructType> > fields_;
 
   DISALLOW_COPY_AND_ASSIGN(JSONValueConverter);
 };
 
 }  // namespace base
 
 #endif  // BASE_JSON_JSON_VALUE_CONVERTER_H_