Convert Pass()→std::move() in //chrome

chrome/browser/tracing/navigation_tracing.cc

 // Copyright 2015 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/tracing/navigation_tracing.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/tracing/crash_service_uploader.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/tracing/tracing_switches.h"
 #include "content/public/browser/background_tracing_config.h"
 #include "content/public/browser/background_tracing_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
@@ skipping 17 matching lines @@
 }
 
 void UploadCallback(const scoped_refptr<base::RefCountedString>& file_contents,
                     scoped_ptr<const base::DictionaryValue> metadata,
                     base::Closure callback) {
   TraceCrashServiceUploader* uploader = new TraceCrashServiceUploader(
       g_browser_process->system_request_context());
 
   uploader->DoUpload(
       file_contents->data(), content::TraceUploader::UNCOMPRESSED_UPLOAD,
-      metadata.Pass(), content::TraceUploader::UploadProgressCallback(),
+      std::move(metadata), content::TraceUploader::UploadProgressCallback(),
       base::Bind(&OnUploadComplete, base::Owned(uploader), callback));
 }
 
 }  // namespace
 
 void SetupNavigationTracing() {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   if (!command_line.HasSwitch(switches::kEnableNavigationTracing) ||
       !command_line.HasSwitch(switches::kTraceUploadURL)) {
     NOTREACHED();
     return;
   }
 
   base::DictionaryValue dict;
   dict.SetString("mode", "REACTIVE_TRACING_MODE");
 
   scoped_ptr<base::ListValue> rules_list(new base::ListValue());
   {
     scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
     rules_dict->SetString("rule", "TRACE_ON_NAVIGATION_UNTIL_TRIGGER_OR_FULL");
     rules_dict->SetString("trigger_name", kNavigationTracingConfig);
     rules_dict->SetString("category", "BENCHMARK_DEEP");
-    rules_list->Append(rules_dict.Pass());
+    rules_list->Append(std::move(rules_dict));
   }
-  dict.Set("configs", rules_list.Pass());
+  dict.Set("configs", std::move(rules_list));
 
   scoped_ptr<content::BackgroundTracingConfig> config(
       content::BackgroundTracingConfig::FromDict(&dict));
   DCHECK(config);
 
   content::BackgroundTracingManager::GetInstance()->SetActiveScenario(
-      config.Pass(), base::Bind(&UploadCallback),
+      std::move(config), base::Bind(&UploadCallback),
       content::BackgroundTracingManager::NO_DATA_FILTERING);
 }
 
 bool NavigationTracingObserver::IsEnabled() {
   return content::BackgroundTracingManager::GetInstance()->HasActiveScenario();
 }
 
 NavigationTracingObserver::NavigationTracingObserver(
     content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents) {
@@ skipping 16 matching lines @@
     content::BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         navigation_handle,
         content::BackgroundTracingManager::StartedFinalizingCallback());
   }
 }
 
 content::BackgroundTracingManager::TriggerHandle
     NavigationTracingObserver::navigation_handle = -1;
 
 }  // namespace tracing