[Extensions API] Remove inline enums

chrome/browser/extensions/api/debugger/debugger_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.
 
 // Implements the Chrome Extensions Debugger API.
 
 #include "chrome/browser/extensions/api/debugger/debugger_api.h"
 
 #include <map>
 #include <set>
@@ skipping 106 matching lines @@
   Profile* profile_;
   scoped_refptr<DevToolsAgentHost> agent_host_;
   std::string extension_id_;
   Debuggee debuggee_;
   content::NotificationRegistrar registrar_;
   int last_request_id_;
   typedef std::map<int, scoped_refptr<DebuggerSendCommandFunction> >
       PendingRequests;
   PendingRequests pending_requests_;
   infobars::InfoBar* infobar_;
-  OnDetach::Reason detach_reason_;
+  api::debugger::DetachReason detach_reason_;
 
   // Listen to extension unloaded notification.
   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
       extension_registry_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsClientHost);
 };
 
 // The member function declarations come after the other class declarations, so
 // they can call members on them.
@@ skipping 166 matching lines @@
     DevToolsAgentHost* agent_host,
     const std::string& extension_id,
     const std::string& extension_name,
     const Debuggee& debuggee,
     infobars::InfoBar* infobar)
     : profile_(profile),
       agent_host_(agent_host),
       extension_id_(extension_id),
       last_request_id_(0),
       infobar_(infobar),
-      detach_reason_(OnDetach::REASON_TARGET_CLOSED),
+      detach_reason_(api::debugger::DETACH_REASON_TARGET_CLOSED),
       extension_registry_observer_(this) {
   CopyDebuggee(&debuggee_, debuggee);
 
   AttachedClientHosts::GetInstance()->Add(this);
 
   // ExtensionRegistryObserver listen extension unloaded and detach debugger
   // from there.
   extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
 
   // RVH-based agents disconnect from their clients when the app is terminating
@@ skipping 29 matching lines @@
     infobar_service->RemoveInfoBar(infobar_);
   }
   AttachedClientHosts::GetInstance()->Remove(this);
 }
 
 // DevToolsAgentHostClient implementation.
 void ExtensionDevToolsClientHost::AgentHostClosed(
     DevToolsAgentHost* agent_host, bool replaced_with_another_client) {
   DCHECK(agent_host == agent_host_.get());
   if (replaced_with_another_client)
-    detach_reason_ = OnDetach::REASON_REPLACED_WITH_DEVTOOLS;
+    detach_reason_ = api::debugger::DETACH_REASON_REPLACED_WITH_DEVTOOLS;
   SendDetachedEvent();
   delete this;
 }
 
 void ExtensionDevToolsClientHost::Close() {
   agent_host_->DetachClient();
   delete this;
 }
 
 void ExtensionDevToolsClientHost::SendMessageToBackend(
     DebuggerSendCommandFunction* function,
     const std::string& method,
     SendCommand::Params::CommandParams* command_params) {
   base::DictionaryValue protocol_request;
   int request_id = ++last_request_id_;
   pending_requests_[request_id] = function;
   protocol_request.SetInteger("id", request_id);
   protocol_request.SetString("method", method);
   if (command_params) {
     protocol_request.Set("params",
                          command_params->additional_properties.DeepCopy());
   }
 
   std::string json_args;
   base::JSONWriter::Write(&protocol_request, &json_args);
   agent_host_->DispatchProtocolMessage(json_args);
 }
 
 void ExtensionDevToolsClientHost::MarkAsDismissed() {
-  detach_reason_ = OnDetach::REASON_CANCELED_BY_USER;
+  detach_reason_ = api::debugger::DETACH_REASON_CANCELED_BY_USER;
 }
 
 void ExtensionDevToolsClientHost::SendDetachedEvent() {
   if (!EventRouter::Get(profile_))
     return;
 
   scoped_ptr<base::ListValue> args(OnDetach::Create(debuggee_,
                                                     detach_reason_));
   scoped_ptr<Event> event(new Event(OnDetach::kEventName, args.Pass()));
   event->restrict_to_browser_context = profile_;
@@ skipping 338 matching lines @@
     const std::vector<DevToolsTargetImpl*>& target_list) {
   scoped_ptr<base::ListValue> result(new base::ListValue());
   for (size_t i = 0; i < target_list.size(); ++i)
     result->Append(SerializeTarget(*target_list[i]));
   STLDeleteContainerPointers(target_list.begin(), target_list.end());
   SetResult(result.release());
   SendResponse(true);
 }
 
 }  // namespace extensions