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

chrome/browser/extensions/api/log_private/log_private_api_chromeos.cc

 // Copyright 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/api/log_private/log_private_api.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
 #include "chrome/browser/extensions/api/log_private/filter_handler.h"
 #include "chrome/browser/extensions/api/log_private/log_parser.h"
 #include "chrome/browser/extensions/api/log_private/syslog_parser.h"
 #include "chrome/browser/feedback/system_logs/scrubbed_system_logs_fetcher.h"
 #include "chrome/browser/io_thread.h"
@@ skipping 44 matching lines @@
 
 scoped_ptr<LogParser> CreateLogParser(const std::string& log_type) {
   if (log_type == "syslog")
     return scoped_ptr<LogParser>(new SyslogParser());
   // TODO(shinfan): Add more parser here
 
   NOTREACHED() << "Invalid log type: " << log_type;
   return  scoped_ptr<LogParser>();
 }
 
-void CollectLogInfo(
-    FilterHandler* filter_handler,
-    system_logs::SystemLogsResponse* logs,
-    std::vector<linked_ptr<api::log_private::LogEntry> >* output) {
+void CollectLogInfo(FilterHandler* filter_handler,
+                    system_logs::SystemLogsResponse* logs,
+                    std::vector<api::log_private::LogEntry>* output) {
   for (system_logs::SystemLogsResponse::const_iterator
       request_it = logs->begin(); request_it != logs->end(); ++request_it) {
     if (!filter_handler->IsValidSource(request_it->first)) {
       continue;
     }
     scoped_ptr<LogParser> parser(CreateLogParser(request_it->first));
     if (parser) {
       parser->Parse(request_it->second, output, filter_handler);
     }
   }
@@ skipping 322 matching lines @@
     fetcher = new system_logs::AboutSystemLogsFetcher();
   }
   fetcher->Fetch(
       base::Bind(&LogPrivateGetHistoricalFunction::OnSystemLogsLoaded, this));
 
   return true;
 }
 
 void LogPrivateGetHistoricalFunction::OnSystemLogsLoaded(
     scoped_ptr<system_logs::SystemLogsResponse> sys_info) {
-  std::vector<linked_ptr<api::log_private::LogEntry> > data;
-
-  CollectLogInfo(filter_handler_.get(), sys_info.get(), &data);
 
   // Prepare result
   api::log_private::Result result;
-  result.data = data;
+  CollectLogInfo(filter_handler_.get(), sys_info.get(), &result.data);
   api::log_private::Filter::Populate(
       *((filter_handler_->GetFilter())->ToValue()), &result.filter);
   SetResult(result.ToValue().release());
   SendResponse(true);
 }
 
 LogPrivateStartEventRecorderFunction::LogPrivateStartEventRecorderFunction() {
 }
 
 LogPrivateStartEventRecorderFunction::~LogPrivateStartEventRecorderFunction() {
@@ skipping 100 matching lines @@
   entry->SetBoolean("isDirectory", false);
   base::ListValue* entry_list = new base::ListValue();
   entry_list->Append(entry);
   response->Set("entries", entry_list);
   response->SetBoolean("multiple", false);
   SetResult(response.release());
   SendResponse(succeeded);
 }
 
 }  // namespace extensions