Cleanup in webkit/glue/

webkit/glue/cpp_bound_class.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.
 
 /*
-  CppBoundClass class: 
+  CppBoundClass class:
   This base class serves as a parent for C++ classes designed to be bound to
   JavaScript objects.
 
   Subclasses should define the constructor to build the property and method
   lists needed to bind this class to a JS object.  They should also declare
   and define member variables and methods to be exposed to JS through
   that object.
 
   See cpp_binding_example.{h|cc} for an example.
 */
@@ skipping 29 matching lines @@
   // as window.<classname>. The owner of the CppBoundObject is responsible for
   // keeping the object around while the frame is alive, and for destroying it
   // afterwards.
   void BindToJavascript(WebFrame* frame, const std::wstring& classname);
 
   // The type of callbacks.
   typedef Callback2<const CppArgumentList&, CppVariant*>::Type Callback;
 
   // Used by a test.  Returns true if a method with name |name| exists,
   // regardless of whether a fallback is registered.
-  bool IsMethodRegistered(std::string name);
- 
+  bool IsMethodRegistered(std::string name) const;
+
  protected:
   // Bind the Javascript method called |name| to the C++ callback |callback|.
   void BindCallback(std::string name, Callback* callback);
-  
+
   // A wrapper for BindCallback, to simplify the common case of binding a
   // method on the current object.  Though not verified here, |method|
   // must be a method of this CppBoundClass subclass.
   template<typename T>
   void BindMethod(std::string name,
       void (T::*method)(const CppArgumentList&, CppVariant*)) {
     Callback* callback =
         NewCallback<T, const CppArgumentList&, CppVariant*>(
             static_cast<T*>(this), method);
     BindCallback(name, callback);
@@ skipping 28 matching lines @@
           NewCallback<T, const CppArgumentList&, CppVariant*>(
               static_cast<T*>(this), method);
       BindFallbackCallback(callback);
     } else {
       BindFallbackCallback(NULL);
     }
   }
 
   // Some fields are protected because some tests depend on accessing them,
   // but otherwise they should be considered private.
- 
+
   typedef std::map<NPIdentifier, CppVariant*> PropertyList;
   typedef std::map<NPIdentifier, Callback*> MethodList;
   // These maps associate names with property and method pointers to be
   // exposed to JavaScript.
   PropertyList properties_;
   MethodList methods_;
 
   // The callback gets invoked when a call is made to an nonexistent method.
   scoped_ptr<Callback> fallback_callback_;
 
  private:
   // NPObject callbacks.
   friend struct CppNPObject;
-  bool HasMethod(NPIdentifier ident);
+  bool HasMethod(NPIdentifier ident) const;
   bool Invoke(NPIdentifier ident, const NPVariant* args, size_t arg_count,
               NPVariant* result);
-  bool HasProperty(NPIdentifier ident);
-  bool GetProperty(NPIdentifier ident, NPVariant* result);
+  bool HasProperty(NPIdentifier ident) const;
+  bool GetProperty(NPIdentifier ident, NPVariant* result) const;
   bool SetProperty(NPIdentifier ident, const NPVariant* value);
 
   // A list of all NPObjects we created and bound in BindToJavascript(), so we
   // can clean them up when we're destroyed.
   typedef std::vector<NPObject*> BoundObjectList;
   BoundObjectList bound_objects_;
 
   DISALLOW_EVIL_CONSTRUCTORS(CppBoundClass);
 };
 
 #endif  // CPP_BOUNDCLASS_H__