[Extensions] Convert APIs to use movable types [1]

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 <string>
 
 #include "base/format_macros.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 113 matching lines @@
 
 void Action::ParseArgUrl(const std::string& url) {
   set_arg_incognito(base::StartsWith(url, constants::kIncognitoUrl,
                                      base::CompareCase::SENSITIVE));
   if (arg_incognito())
     set_arg_url(GURL(url.substr(strlen(constants::kIncognitoUrl))));
   else
     set_arg_url(GURL(url));
 }
 
-scoped_ptr<ExtensionActivity> Action::ConvertToExtensionActivity() {
-  scoped_ptr<ExtensionActivity> result(new ExtensionActivity);
+ExtensionActivity Action::ConvertToExtensionActivity() {
+  ExtensionActivity result;
 
   // 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 = activity_log::EXTENSION_ACTIVITY_TYPE_API_CALL;
+      result.activity_type = activity_log::EXTENSION_ACTIVITY_TYPE_API_CALL;
       break;
     case ACTION_API_EVENT:
-      result->activity_type = activity_log::EXTENSION_ACTIVITY_TYPE_API_EVENT;
+      result.activity_type = activity_log::EXTENSION_ACTIVITY_TYPE_API_EVENT;
       break;
     case ACTION_CONTENT_SCRIPT:
-      result->activity_type =
+      result.activity_type =
           activity_log::EXTENSION_ACTIVITY_TYPE_CONTENT_SCRIPT;
       break;
     case ACTION_DOM_ACCESS:
-      result->activity_type = activity_log::EXTENSION_ACTIVITY_TYPE_DOM_ACCESS;
+      result.activity_type = activity_log::EXTENSION_ACTIVITY_TYPE_DOM_ACCESS;
       break;
     case ACTION_DOM_EVENT:
-      result->activity_type = activity_log::EXTENSION_ACTIVITY_TYPE_DOM_EVENT;
+      result.activity_type = activity_log::EXTENSION_ACTIVITY_TYPE_DOM_EVENT;
       break;
     case ACTION_WEB_REQUEST:
-      result->activity_type = activity_log::EXTENSION_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 = activity_log::EXTENSION_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())));
+  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(
+    result.activity_id.reset(
         new std::string(base::StringPrintf("%" PRId64, action_id())));
   if (page_url().is_valid()) {
     if (!page_title().empty())
-      result->page_title.reset(new std::string(page_title()));
-    result->page_url.reset(new std::string(SerializePageUrl()));
+      result.page_title.reset(new std::string(page_title()));
+    result.page_url.reset(new std::string(SerializePageUrl()));
   }
   if (arg_url().is_valid())
-    result->arg_url.reset(new std::string(SerializeArgUrl()));
+    result.arg_url.reset(new std::string(SerializeArgUrl()));
 
   if (other()) {
     scoped_ptr<ExtensionActivity::Other> other_field(
         new ExtensionActivity::Other);
     bool prerender;
     if (other()->GetBooleanWithoutPathExpansion(constants::kActionPrerender,
                                                 &prerender)) {
       other_field->prerender.reset(new bool(prerender));
     }
     const base::DictionaryValue* web_request;
@@ skipping 36 matching lines @@
           other_field->dom_verb =
               activity_log::EXTENSION_ACTIVITY_DOM_VERB_MODIFIED;
           break;
         default:
           other_field->dom_verb =
               activity_log::EXTENSION_ACTIVITY_DOM_VERB_NONE;
       }
     } else {
       other_field->dom_verb = activity_log::EXTENSION_ACTIVITY_DOM_VERB_NONE;
     }
-    result->other.reset(other_field.release());
+    result.other.reset(other_field.release());
   }
 
   return result;
 }
 
 std::string Action::PrintForDebug() const {
   std::string result = base::StringPrintf("ACTION ID=%" PRId64, action_id());
   result += " EXTENSION ID=" + extension_id() + " CATEGORY=";
   switch (action_type_) {
     case ACTION_API_CALL:
@@ skipping 108 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