Replaced BaseNPObject with DefaultNPObject because......

o3d/gpu_plugin/np_utils/np_utils.h

 // Copyright (c) 2006-2008 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 O3D_GPU_PLUGIN_NP_UTILS_NP_UTILS_H_
 #define O3D_GPU_PLUGIN_NP_UTILS_NP_UTILS_H_
 
 #include <string>
 
 #include "o3d/gpu_plugin/np_utils/np_browser.h"
+#include "o3d/gpu_plugin/np_utils/np_class.h"
 #include "o3d/gpu_plugin/np_utils/np_object_pointer.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npruntime.h"
 
 namespace o3d {
 namespace gpu_plugin {
 
 // Convert NPVariant to C++ type. Returns whether the conversion was successful.
 bool NPVariantToValue(bool* value, const NPVariant& variant);
 bool NPVariantToValue(int32* value, const NPVariant& variant);
 bool NPVariantToValue(float* value, const NPVariant& variant);
 bool NPVariantToValue(double* value, const NPVariant& variant);
 bool NPVariantToValue(std::string* value, const NPVariant& variant);
 
 template <typename T>
 bool NPVariantToValue(NPObjectPointer<T>* value,
                       const NPVariant& variant) {
   if (NPVARIANT_IS_NULL(variant)) {
     *value = NPObjectPointer<T>();
     return true;
   } else if (NPVARIANT_IS_OBJECT(variant)) {
     NPObject* object = NPVARIANT_TO_OBJECT(variant);
-    if (object->_class == BaseNPObject::GetNPClass<T>()) {
+    if (object->_class == NPGetClass<T>()) {
       *value = NPObjectPointer<T>(static_cast<T*>(
           NPVARIANT_TO_OBJECT(variant)));
       return true;
     }
   }
 
   return false;
 }
 
 // Specialization for NPObject does not check for mismatched NPClass.
@@ skipping 27 matching lines @@
   } else {
     NULL_TO_NPVARIANT(*variant);
   }
 }
 
 // NPVariant that automatically manages lifetime of string and object variants.
 class SmartNPVariant : public NPVariant {
  public:
   SmartNPVariant();
   SmartNPVariant(const SmartNPVariant& rhs);
-  SmartNPVariant(const NPVariant& rhs);
+  explicit SmartNPVariant(const NPVariant& rhs);
 
   template <typename T>
   explicit SmartNPVariant(const T& v) {
     ValueToNPVariant(v, this);
   }
 
   ~SmartNPVariant();
 
   SmartNPVariant& operator=(const SmartNPVariant& rhs);
   SmartNPVariant& operator=(const NPVariant& rhs);
@@ skipping 162 matching lines @@
       NPBrowser::get()->GetStringIdentifier(name),
       &variant);
 }
 
 bool NPRemoveProperty(NPP npp,
                       const NPObjectPointer<NPObject>& object,
                       const NPUTF8* name);
 
 template <typename NPObjectType>
 NPObjectPointer<NPObjectType> NPCreateObject(NPP npp) {
-  const NPClass* np_class = BaseNPObject::GetNPClass<NPObjectType>();
+  const NPClass* np_class = NPGetClass<NPObjectType>();
   NPObjectType* object = static_cast<NPObjectType*>(
       NPBrowser::get()->CreateObject(npp, np_class));
   return NPObjectPointer<NPObjectType>::FromReturned(object);
 }
 
 }  // namespace gpu_plugin
 }  // namespace o3d
 
 #endif  // O3D_GPU_PLUGIN_NP_UTILS_NP_UTILS_H_