[Extensions API] Remove inline enums

chrome/browser/extensions/activity_log/activity_actions.cc

 // Copyright (c) 2013 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/activity_log/activity_actions.h"
 
 #include <algorithm>  // for std::find.
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/rappor/rappor_service.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/dom_action_types.h"
 #include "sql/statement.h"
 #include "url/gurl.h"
 
 namespace constants = activity_log_constants;
+namespace activity_log = extensions::api::activity_log_private;
 
 namespace extensions {
 
 namespace {
 
 // The "Extensions.PossibleAdInjection2" metric uses different Rappor
 // parameters than the original metric.
 const char kExtensionAdInjectionRapporMetricName[] =
     "Extensions.PossibleAdInjection2";
 
@@ skipping 167 matching lines @@
 }
 
 scoped_ptr<ExtensionActivity> Action::ConvertToExtensionActivity() {
   scoped_ptr<ExtensionActivity> result(new ExtensionActivity);
 
   // We do this translation instead of using the same enum because the database
   // values need to be stable; this allows us to change the extension API
   // without affecting the database.
   switch (action_type()) {
     case ACTION_API_CALL:
-      result->activity_type = ExtensionActivity::ACTIVITY_TYPE_API_CALL;
+      result->activity_type = activity_log::EXTENSION_ACTIVITY_TYPE_API_CALL;
       break;
     case ACTION_API_EVENT:
-      result->activity_type = ExtensionActivity::ACTIVITY_TYPE_API_EVENT;
+      result->activity_type = activity_log::EXTENSION_ACTIVITY_TYPE_API_EVENT;
       break;
     case ACTION_CONTENT_SCRIPT:
-      result->activity_type = ExtensionActivity::ACTIVITY_TYPE_CONTENT_SCRIPT;
+      result->activity_type =
+          activity_log::EXTENSION_ACTIVITY_TYPE_CONTENT_SCRIPT;
       break;
     case ACTION_DOM_ACCESS:
-      result->activity_type = ExtensionActivity::ACTIVITY_TYPE_DOM_ACCESS;
+      result->activity_type = activity_log::EXTENSION_ACTIVITY_TYPE_DOM_ACCESS;
       break;
     case ACTION_DOM_EVENT:
-      result->activity_type = ExtensionActivity::ACTIVITY_TYPE_DOM_EVENT;
+      result->activity_type = activity_log::EXTENSION_ACTIVITY_TYPE_DOM_EVENT;
       break;
     case ACTION_WEB_REQUEST:
-      result->activity_type = ExtensionActivity::ACTIVITY_TYPE_WEB_REQUEST;
+      result->activity_type = activity_log::EXTENSION_ACTIVITY_TYPE_WEB_REQUEST;
       break;
     case UNUSED_ACTION_API_BLOCKED:
     case ACTION_ANY:
     default:
       // This shouldn't be reached, but some people might have old or otherwise
       // weird db entries. Treat it like an API call if that happens.
-      result->activity_type = ExtensionActivity::ACTIVITY_TYPE_API_CALL;
+      result->activity_type = activity_log::EXTENSION_ACTIVITY_TYPE_API_CALL;
       break;
   }
 
   result->extension_id.reset(new std::string(extension_id()));
   result->time.reset(new double(time().ToJsTime()));
   result->count.reset(new double(count()));
   result->api_call.reset(new std::string(api_name()));
   result->args.reset(new std::string(Serialize(args())));
   if (action_id() != -1)
     result->activity_id.reset(
@@ skipping 21 matching lines @@
           ActivityLogPolicy::Util::Serialize(web_request)));
     }
     std::string extra;
     if (other()->GetStringWithoutPathExpansion(constants::kActionExtra, &extra))
       other_field->extra.reset(new std::string(extra));
     int dom_verb;
     if (other()->GetIntegerWithoutPathExpansion(constants::kActionDomVerb,
                                                 &dom_verb)) {
       switch (static_cast<DomActionType::Type>(dom_verb)) {
         case DomActionType::GETTER:
-          other_field->dom_verb = ExtensionActivity::Other::DOM_VERB_GETTER;
+          other_field->dom_verb =
+              activity_log::EXTENSION_ACTIVITY_DOM_VERB_GETTER;
           break;
         case DomActionType::SETTER:
-          other_field->dom_verb = ExtensionActivity::Other::DOM_VERB_SETTER;
+          other_field->dom_verb =
+              activity_log::EXTENSION_ACTIVITY_DOM_VERB_SETTER;
           break;
         case DomActionType::METHOD:
-          other_field->dom_verb = ExtensionActivity::Other::DOM_VERB_METHOD;
+          other_field->dom_verb =
+              activity_log::EXTENSION_ACTIVITY_DOM_VERB_METHOD;
           break;
         case DomActionType::INSERTED:
-          other_field->dom_verb = ExtensionActivity::Other::DOM_VERB_INSERTED;
+          other_field->dom_verb =
+              activity_log::EXTENSION_ACTIVITY_DOM_VERB_INSERTED;
           break;
         case DomActionType::XHR:
-          other_field->dom_verb = ExtensionActivity::Other::DOM_VERB_XHR;
+          other_field->dom_verb = activity_log::EXTENSION_ACTIVITY_DOM_VERB_XHR;
           break;
         case DomActionType::WEBREQUEST:
-          other_field->dom_verb = ExtensionActivity::Other::DOM_VERB_WEBREQUEST;
+          other_field->dom_verb =
+              activity_log::EXTENSION_ACTIVITY_DOM_VERB_WEBREQUEST;
           break;
         case DomActionType::MODIFIED:
-          other_field->dom_verb = ExtensionActivity::Other::DOM_VERB_MODIFIED;
+          other_field->dom_verb =
+              activity_log::EXTENSION_ACTIVITY_DOM_VERB_MODIFIED;
           break;
         default:
-          other_field->dom_verb = ExtensionActivity::Other::DOM_VERB_NONE;
+          other_field->dom_verb =
+              activity_log::EXTENSION_ACTIVITY_DOM_VERB_NONE;
       }
     } else {
-      other_field->dom_verb = ExtensionActivity::Other::DOM_VERB_NONE;
+      other_field->dom_verb = activity_log::EXTENSION_ACTIVITY_DOM_VERB_NONE;
     }
     result->other.reset(other_field.release());
   }
 
   return result.Pass();
 }
 
 std::string Action::PrintForDebug() const {
   std::string result = base::StringPrintf("ACTION ID=%" PRId64, action_id());
   result += " EXTENSION ID=" + extension_id() + " CATEGORY=";
@@ skipping 225 matching lines @@
     std::string rhs_other = ActivityLogPolicy::Util::Serialize(rhs->other());
     if (lhs_other != rhs_other)
       return lhs_other < rhs_other;
   }
 
   // All fields compare as equal if this point is reached.
   return false;
 }
 
 }  // namespace extensions