[Extensions] Remove 'use_movable_types' from code generation

chrome/browser/extensions/api/history/history_api.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.

[Devlin, 2016/04/01 01:38:24]

Missed this one because the json has "compler_options" instead of
"compiler_options" - but didn't seem worth fixing the json since this patch
removes the dependency on it and the next will remove it from the json/idls.

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/api/history/history_api.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 20 matching lines @@
 #include "components/prefs/pref_service.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_system_provider.h"
 #include "extensions/browser/extensions_browser_client.h"
 
 namespace extensions {
 
 using api::history::HistoryItem;
 using api::history::VisitItem;
 
-typedef std::vector<linked_ptr<api::history::HistoryItem> >
-    HistoryItemList;
-typedef std::vector<linked_ptr<api::history::VisitItem> >
-    VisitItemList;
+typedef std::vector<api::history::HistoryItem> HistoryItemList;
+typedef std::vector<api::history::VisitItem> VisitItemList;
 
 namespace AddUrl = api::history::AddUrl;
 namespace DeleteUrl = api::history::DeleteUrl;
 namespace DeleteRange = api::history::DeleteRange;
 namespace GetVisits = api::history::GetVisits;
 namespace OnVisited = api::history::OnVisited;
 namespace OnVisitRemoved = api::history::OnVisitRemoved;
 namespace Search = api::history::Search;
 
 namespace {
 
 const char kInvalidUrlError[] = "Url is invalid.";
 const char kDeleteProhibitedError[] = "Browsing history is not allowed to be "
                                       "deleted.";
 
 double MilliSecondsFromTime(const base::Time& time) {
   return 1000 * time.ToDoubleT();
 }
 
-scoped_ptr<HistoryItem> GetHistoryItem(const history::URLRow& row) {
-  scoped_ptr<HistoryItem> history_item(new HistoryItem());
+HistoryItem GetHistoryItem(const history::URLRow& row) {
+  HistoryItem history_item;
 
-  history_item->id = base::Int64ToString(row.id());
-  history_item->url.reset(new std::string(row.url().spec()));
-  history_item->title.reset(new std::string(base::UTF16ToUTF8(row.title())));
-  history_item->last_visit_time.reset(
+  history_item.id = base::Int64ToString(row.id());
+  history_item.url.reset(new std::string(row.url().spec()));
+  history_item.title.reset(new std::string(base::UTF16ToUTF8(row.title())));
+  history_item.last_visit_time.reset(
       new double(MilliSecondsFromTime(row.last_visit())));
-  history_item->typed_count.reset(new int(row.typed_count()));
-  history_item->visit_count.reset(new int(row.visit_count()));
+  history_item.typed_count.reset(new int(row.typed_count()));
+  history_item.visit_count.reset(new int(row.visit_count()));
 
   return history_item;
 }
 
-scoped_ptr<VisitItem> GetVisitItem(const history::VisitRow& row) {
-  scoped_ptr<VisitItem> visit_item(new VisitItem());
+VisitItem GetVisitItem(const history::VisitRow& row) {
+  VisitItem visit_item;
 
-  visit_item->id = base::Int64ToString(row.url_id);
-  visit_item->visit_id = base::Int64ToString(row.visit_id);
-  visit_item->visit_time.reset(
-      new double(MilliSecondsFromTime(row.visit_time)));
-  visit_item->referring_visit_id = base::Int64ToString(row.referring_visit);
+  visit_item.id = base::Int64ToString(row.url_id);
+  visit_item.visit_id = base::Int64ToString(row.visit_id);
+  visit_item.visit_time.reset(new double(MilliSecondsFromTime(row.visit_time)));
+  visit_item.referring_visit_id = base::Int64ToString(row.referring_visit);
 
   api::history::TransitionType transition = api::history::TRANSITION_TYPE_LINK;
   switch (row.transition & ui::PAGE_TRANSITION_CORE_MASK) {
     case ui::PAGE_TRANSITION_LINK:
       transition = api::history::TRANSITION_TYPE_LINK;
       break;
     case ui::PAGE_TRANSITION_TYPED:
       transition = api::history::TRANSITION_TYPE_TYPED;
       break;
     case ui::PAGE_TRANSITION_AUTO_BOOKMARK:
@@ skipping 20 matching lines @@
     case ui::PAGE_TRANSITION_KEYWORD:
       transition = api::history::TRANSITION_TYPE_KEYWORD;
       break;
     case ui::PAGE_TRANSITION_KEYWORD_GENERATED:
       transition = api::history::TRANSITION_TYPE_KEYWORD_GENERATED;
       break;
     default:
       DCHECK(false);
   }
 
-  visit_item->transition = transition;
+  visit_item.transition = transition;
 
   return visit_item;
 }
 
 }  // namespace
 
 HistoryEventRouter::HistoryEventRouter(Profile* profile,
                                        history::HistoryService* history_service)
     : profile_(profile), history_service_observer_(this) {
   DCHECK(profile);
   history_service_observer_.Add(history_service);
 }
 
 HistoryEventRouter::~HistoryEventRouter() {
 }
 
 void HistoryEventRouter::OnURLVisited(history::HistoryService* history_service,
                                       ui::PageTransition transition,
                                       const history::URLRow& row,
                                       const history::RedirectList& redirects,
                                       base::Time visit_time) {
-  scoped_ptr<HistoryItem> history_item = GetHistoryItem(row);
-  scoped_ptr<base::ListValue> args = OnVisited::Create(*history_item);
+  scoped_ptr<base::ListValue> args = OnVisited::Create(GetHistoryItem(row));
   DispatchEvent(profile_, events::HISTORY_ON_VISITED,
                 api::history::OnVisited::kEventName, std::move(args));
 }
 
 void HistoryEventRouter::OnURLsDeleted(history::HistoryService* history_service,
                                        bool all_history,
                                        bool expired,
                                        const history::URLRows& deleted_rows,
                                        const std::set<GURL>& favicon_urls) {
   OnVisitRemoved::Removed removed;
@@ skipping 131 matching lines @@
                &task_tracker_);
   return true;
 }
 
 void HistoryGetVisitsFunction::QueryComplete(
     bool success,
     const history::URLRow& url_row,
     const history::VisitVector& visits) {
   VisitItemList visit_item_vec;
   if (success && !visits.empty()) {
-    for (history::VisitVector::const_iterator iterator = visits.begin();
-         iterator != visits.end();
-         ++iterator) {
-      visit_item_vec.push_back(make_linked_ptr(
-          GetVisitItem(*iterator).release()));
-    }
+    for (const history::VisitRow& visit : visits)
+      visit_item_vec.push_back(GetVisitItem(visit));
   }
 
   results_ = GetVisits::Results::Create(visit_item_vec);
   SendAsyncResponse();
 }
 
 bool HistorySearchFunction::RunAsyncImpl() {
   scoped_ptr<Search::Params> params(Search::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
@@ skipping 17 matching lines @@
                    base::Bind(&HistorySearchFunction::SearchComplete,
                               base::Unretained(this)),
                    &task_tracker_);
 
   return true;
 }
 
 void HistorySearchFunction::SearchComplete(history::QueryResults* results) {
   HistoryItemList history_item_vec;
   if (results && !results->empty()) {
-    for (history::QueryResults::URLResultVector::const_iterator iterator =
-            results->begin();
-         iterator != results->end();
-        ++iterator) {
-      history_item_vec.push_back(make_linked_ptr(
-          GetHistoryItem(**iterator).release()));
-    }
+    for (const history::URLResult* item : *results)
+      history_item_vec.push_back(GetHistoryItem(*item));
   }
   results_ = Search::Results::Create(history_item_vec);
   SendAsyncResponse();
 }
 
 bool HistoryAddUrlFunction::RunAsync() {
   scoped_ptr<AddUrl::Params> params(AddUrl::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   GURL url;
@@ skipping 97 matching lines @@
   }
 
   return true;
 }
 
 void HistoryDeleteAllFunction::DeleteComplete() {
   SendAsyncResponse();
 }
 
 }  // namespace extensions