Cleanup: Update TestObject.h to Chromium style.

content/shell/tools/plugin/TestObject.cpp

 // Copyright 2014 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.
 
 /*
  * Copyright (C) 2007 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "TestObject.h"
+#include "content/shell/tools/plugin/test_object.h"
+
 #include "PluginObject.h"
 
 #include <string.h>
 #include <stdlib.h>
 
 static bool testEnumerate(NPObject* npobj,
                           NPIdentifier** value,
                           uint32_t* count);
 static bool testHasMethod(NPObject*, NPIdentifier name);
 static bool testInvoke(NPObject*,
                        NPIdentifier name,
                        const NPVariant* args,
                        uint32_t argCount,
                        NPVariant* result);
 static bool testHasProperty(NPObject*, NPIdentifier name);
 static bool testGetProperty(NPObject*, NPIdentifier name, NPVariant*);
 static NPObject* testAllocate(NPP npp, NPClass* theClass);
 static void testDeallocate(NPObject* obj);
 static bool testConstruct(NPObject* obj,
                           const NPVariant* args,
                           uint32_t argCount,
                           NPVariant* result);
 
-static NPClass testClass = {
+static NPClass g_test_class = {
     NP_CLASS_STRUCT_VERSION, testAllocate, testDeallocate, 0,
     testHasMethod,           testInvoke,   0,              testHasProperty,
     testGetProperty,         0,            0,              testEnumerate,
     testConstruct};
 
-NPClass* getTestClass(void) { return &testClass; }
 
-static int testObjectCount = 0;
-
-int getTestObjectCount() { return testObjectCount; }
+static int g_test_object_count = 0;
 
 typedef struct {
   NPObject header;
   NPObject* testObject;
 } TestObject;
 
 static bool identifiersInitialized = false;
 
 #define NUM_ENUMERATABLE_TEST_IDENTIFIERS 2
 
@@ skipping 21 matching lines @@
   browser->getstringidentifiers(
       testIdentifierNames, NUM_TEST_IDENTIFIERS, testIdentifiers);
   browser->getstringidentifiers(
       testMethodIdentifierNames, NUM_METHOD_IDENTIFIERS, testMethodIdentifiers);
 }
 
 static NPObject* testAllocate(NPP npp, NPClass* /*theClass*/) {
   TestObject* newInstance =
       static_cast<TestObject*>(malloc(sizeof(TestObject)));
   newInstance->testObject = 0;
-  ++testObjectCount;
+  ++g_test_object_count;
 
   if (!identifiersInitialized) {
     identifiersInitialized = true;
     initializeIdentifiers();
   }
 
   return reinterpret_cast<NPObject*>(newInstance);
 }
 
 static void testDeallocate(NPObject* obj) {
   TestObject* testObject = reinterpret_cast<TestObject*>(obj);
   if (testObject->testObject)
     browser->releaseobject(testObject->testObject);
 
-  --testObjectCount;
+  --g_test_object_count;
   free(obj);
 }
 
 static bool testHasMethod(NPObject*, NPIdentifier name) {
   for (unsigned i = 0; i < NUM_METHOD_IDENTIFIERS; i++) {
     if (testMethodIdentifiers[i] == name)
       return true;
   }
   return false;
 }
@@ skipping 37 matching lines @@
   if (name == testIdentifiers[ID_PROPERTY_OBJECT_POINTER]) {
     int32_t objectPointer =
         static_cast<int32_t>(reinterpret_cast<long long>(npobj));
 
     INT32_TO_NPVARIANT(objectPointer, *result);
     return true;
   }
   if (name == testIdentifiers[ID_PROPERTY_TEST_OBJECT]) {
     TestObject* testObject = reinterpret_cast<TestObject*>(npobj);
     if (!testObject->testObject)
-      testObject->testObject = browser->createobject(0, &testClass);
+      testObject->testObject = browser->createobject(0, &g_test_class);
     browser->retainobject(testObject->testObject);
     OBJECT_TO_NPVARIANT(testObject->testObject, *result);
     return true;
   }
   if (name == testIdentifiers[ID_PROPERTY_REF_COUNT]) {
     INT32_TO_NPVARIANT(npobj->referenceCount, *result);
     return true;
   }
 
   return false;
@@ skipping 16 matching lines @@
 static bool testConstruct(NPObject* npobj,
                           const NPVariant* /*args*/,
                           uint32_t /*argCount*/,
                           NPVariant* result) {
   browser->retainobject(npobj);
 
   // Just return the same object.
   OBJECT_TO_NPVARIANT(npobj, *result);
   return true;
 }
+
+namespace content {
+
+NPClass* GetTestClass() { return &g_test_class; }
+
+int GetTestObjectCount() { return g_test_object_count; }
+
+}  // namespace content