RefCounted types should not have public destructors, chrome/browser/extensions

chrome/browser/extensions/extension_input_ime_api.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 "chrome/browser/extensions/extension_input_ime_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
@@ skipping 106 matching lines @@
 
       if (!ReadMenuItems(sub_list, &(output->back().children))) {
         return false;
       }
     }
   }
 
   return true;
 }
 
-}
+}  // namespace
 
 namespace events {
 
 const char kOnActivate[] = "input.ime.onActivate";
 const char kOnDeactivated[] = "input.ime.onDeactivated";
 const char kOnFocus[] = "input.ime.onFocus";
 const char kOnBlur[] = "input.ime.onBlur";
 const char kOnInputContextUpdate[] = "input.ime.onInputContextUpdate";
 const char kOnKeyEvent[] = "input.ime.onKeyEvent";
 const char kOnCandidateClicked[] = "input.ime.onCandidateClicked";
 const char kOnMenuItemActivated[] = "input.ime.onMenuItemActivated";
 
 }  // namespace events
 
 namespace chromeos {
 class ImeObserver : public chromeos::InputMethodEngine::Observer {
  public:
   ImeObserver(Profile* profile, const std::string& extension_id,
               const std::string& engine_id) :
     profile_(profile),
     extension_id_(extension_id),
     engine_id_(engine_id) {
   }
 
-  virtual ~ImeObserver() {
-  }
+  virtual ~ImeObserver() {}
 
   virtual void OnActivate(const std::string& engine_id) {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     ListValue args;
     args.Append(Value::CreateStringValue(engine_id));
 
     std::string json_args;
     base::JSONWriter::Write(&args, &json_args);
@@ skipping 140 matching lines @@
         GURL());
   }
 
  private:
   Profile* profile_;
   std::string extension_id_;
   std::string engine_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImeObserver);
 };
+
 }  // namespace chromeos
 
-
 ExtensionInputImeEventRouter*
 ExtensionInputImeEventRouter::GetInstance() {
   return Singleton<ExtensionInputImeEventRouter>::get();
 }
 
-ExtensionInputImeEventRouter::ExtensionInputImeEventRouter()
-  : next_request_id_(1) {
-}
-
-ExtensionInputImeEventRouter::~ExtensionInputImeEventRouter() {
-}
-
-void ExtensionInputImeEventRouter::Init() {
-}
+void ExtensionInputImeEventRouter::Init() {}
 
 #if defined(OS_CHROMEOS)
 bool ExtensionInputImeEventRouter::RegisterIme(
     Profile* profile,
     const std::string& extension_id,
     const Extension::InputComponentInfo& component) {
   VLOG(1) << "RegisterIme: " << extension_id << " id: " << component.id;
 
   std::map<std::string, chromeos::InputMethodEngine*>& engine_map =
       engines_[extension_id];
@@ skipping 117 matching lines @@
     const std::string& engine_id,
     chromeos::input_method::KeyEventHandle* key_data) {
   std::string request_id = base::IntToString(next_request_id_);
   ++next_request_id_;
 
   request_map_[request_id] = std::make_pair(engine_id, key_data);
 
   return request_id;
 }
 
+ExtensionInputImeEventRouter::ExtensionInputImeEventRouter()
+  : next_request_id_(1) {
+}
+
+ExtensionInputImeEventRouter::~ExtensionInputImeEventRouter() {}
+
 bool SetCompositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
     result_.reset(Value::CreateBooleanValue(false));
     return true;
   }
 
   DictionaryValue* args;
@@ skipping 346 matching lines @@
 
   bool handled = false;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &handled));
 
   ExtensionInputImeEventRouter::GetInstance()->OnEventHandled(
       extension_id(), request_id_str, handled);
 
   return true;
 }
 #endif