RefCounted types should not have public destructors

gpu/command_buffer/service/shader_translator.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 "gpu/command_buffer/service/shader_translator.h"
 
 #include <string.h>
 #include <algorithm>
 
 #include "base/at_exit.h"
 #include "base/logging.h"
 
 namespace {
+
+using gpu::gles2::ShaderTranslator;
+
 void FinalizeShaderTranslator(void* /* dummy */) {
   ShFinalize();
 }
 
 bool InitializeShaderTranslator() {
   static bool initialized = false;
   if (!initialized && ShInitialize()) {
     base::AtExitManager::RegisterCallback(&FinalizeShaderTranslator, NULL);
     initialized = true;
   }
   return initialized;
 }
 
-using gpu::gles2::ShaderTranslator;
 void GetVariableInfo(ShHandle compiler, ShShaderInfo var_type,
                      ShaderTranslator::VariableMap* var_map) {
   int name_len = 0, mapped_name_len = 0;
   switch (var_type) {
     case SH_ACTIVE_ATTRIBUTES:
       ShGetInfo(compiler, SH_ACTIVE_ATTRIBUTE_MAX_LENGTH, &name_len);
       break;
     case SH_ACTIVE_UNIFORMS:
       ShGetInfo(compiler, SH_ACTIVE_UNIFORM_MAX_LENGTH, &name_len);
       break;
@@ skipping 27 matching lines @@
     // to handle long struct field name mapping before we can do this.
     // Also, we should modify the ANGLE interface to also return a length
     // for mapped_name.
     std::string name_string(name.get(), std::min(len, name_len - 1));
     mapped_name.get()[mapped_name_len - 1] = '\0';
 
     ShaderTranslator::VariableInfo info(type, size, name_string);
     (*var_map)[mapped_name.get()] = info;
   }
 }
+
 }  // namespace
 
 namespace gpu {
 namespace gles2 {
 
 ShaderTranslator::DestructionObserver::DestructionObserver() {
 }
 
 ShaderTranslator::DestructionObserver::~DestructionObserver() {
 }
 
 ShaderTranslator::ShaderTranslator()
     : compiler_(NULL),
       implementation_is_glsl_es_(false),
       needs_built_in_function_emulation_(false) {
 }
 
-ShaderTranslator::~ShaderTranslator() {
-  FOR_EACH_OBSERVER(DestructionObserver,
-                    destruction_observers_,
-                    OnDestruct(this));
-
-  if (compiler_ != NULL)
-    ShDestruct(compiler_);
-}
-
 bool ShaderTranslator::Init(
     ShShaderType shader_type,
     ShShaderSpec shader_spec,
     const ShBuiltInResources* resources,
     ShaderTranslatorInterface::GlslImplementationType glsl_implementation_type,
     ShaderTranslatorInterface::GlslBuiltInFunctionBehavior
         glsl_built_in_function_behavior) {
   // Make sure Init is called only once.
   DCHECK(compiler_ == NULL);
   DCHECK(shader_type == SH_FRAGMENT_SHADER || shader_type == SH_VERTEX_SHADER);
@@ skipping 73 matching lines @@
 void ShaderTranslator::AddDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.AddObserver(observer);
 }
 
 void ShaderTranslator::RemoveDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.RemoveObserver(observer);
 }
 
+ShaderTranslator::~ShaderTranslator() {
+  FOR_EACH_OBSERVER(DestructionObserver,
+                    destruction_observers_,
+                    OnDestruct(this));
+
+  if (compiler_ != NULL)
+    ShDestruct(compiler_);
+}
+
 void ShaderTranslator::ClearResults() {
   translated_shader_.reset();
   info_log_.reset();
   attrib_map_.clear();
   uniform_map_.clear();
 }
 
 }  // namespace gles2
 }  // namespace gpu