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

chrome/browser/extensions/api/mdns/mdns_api.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/mdns/mdns_api.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/lazy_instance.h"
@@ skipping 126 matching lines @@
       ++i_prev;
     }
   }
   prev_service_counts_.swap(current_service_counts);
 }
 
 void MDnsAPI::OnDnsSdEvent(const std::string& service_type,
                            const DnsSdRegistry::DnsSdServiceList& services) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  std::vector<linked_ptr<mdns::MDnsService> > args;
-  for (DnsSdRegistry::DnsSdServiceList::const_iterator it = services.begin();
-       it != services.end(); ++it) {
+  std::vector<mdns::MDnsService> args;
+  for (const DnsSdService& service : services) {
     if (static_cast<int>(args.size()) ==
         api::mdns::MAX_SERVICE_INSTANCES_PER_EVENT) {
       // TODO(reddaly): This is not the most meaningful way of notifying the
       // application that something bad happened.  It will go to the user's
       // console (which most users don't look at)and the developer will be none
       // the wiser.  Instead, changing the event to pass the number of
       // discovered instances would allow the caller to know when the list is
       // truncated and tell the user something meaningful in the extension/app.
       WriteToConsole(service_type,
                      content::CONSOLE_MESSAGE_LEVEL_WARNING,
                      base::StringPrintf(
                          "Truncating number of service instances in "
                          "onServiceList to maximum allowed: %d",
                          api::mdns::MAX_SERVICE_INSTANCES_PER_EVENT));
       break;
     }
-    linked_ptr<mdns::MDnsService> mdns_service =
-        make_linked_ptr(new mdns::MDnsService);
-    mdns_service->service_name = (*it).service_name;
-    mdns_service->service_host_port = (*it).service_host_port;
-    mdns_service->ip_address = (*it).ip_address;
-    mdns_service->service_data = (*it).service_data;
-    args.push_back(mdns_service);
+    mdns::MDnsService mdns_service;
+    mdns_service.service_name = service.service_name;
+    mdns_service.service_host_port = service.service_host_port;
+    mdns_service.ip_address = service.ip_address;
+    mdns_service.service_data = service.service_data;
+    args.push_back(std::move(mdns_service));
   }
 
   scoped_ptr<base::ListValue> results = mdns::OnServiceList::Create(args);
   scoped_ptr<Event> event(new Event(events::MDNS_ON_SERVICE_LIST,
                                     mdns::OnServiceList::kEventName,
                                     std::move(results)));
   event->restrict_to_browser_context = browser_context_;
   event->filter_info.SetServiceType(service_type);
 
   // TODO(justinlin): To avoid having listeners without filters getting all
@@ skipping 85 matching lines @@
 AsyncApiFunction::ResponseAction MdnsForceDiscoveryFunction::Run() {
   MDnsAPI* api = MDnsAPI::Get(browser_context());
   if (!api) {
     return RespondNow(Error("Unknown error."));
   }
   api->ForceDiscovery();
   return RespondNow(NoArguments());
 }
 
 }  // namespace extensions