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

chrome/browser/media/desktop_capture_access_handler.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/media/desktop_capture_access_handler.h"
 
+#include <utility>
+
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/media/desktop_streams_registry.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
@@ skipping 96 matching lines @@
     if (application_title == registered_extension_name) {
       ui = ScreenCaptureNotificationUI::Create(l10n_util::GetStringFUTF16(
           IDS_MEDIA_SCREEN_CAPTURE_NOTIFICATION_TEXT, application_title));
     } else {
       ui = ScreenCaptureNotificationUI::Create(l10n_util::GetStringFUTF16(
           IDS_MEDIA_SCREEN_CAPTURE_NOTIFICATION_TEXT_DELEGATED,
           registered_extension_name, application_title));
     }
   }
 
-  return ui.Pass();
+  return ui;
 }
 
 #if !defined(OS_ANDROID)
 // Find browser or app window from a given |web_contents|.
 gfx::NativeWindow FindParentWindowForWebContents(
     content::WebContents* web_contents) {
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
   if (browser && browser->window())
     return browser->window()->GetNativeWindow();
 
@@ skipping 126 matching lines @@
                                        application_title);
       DCHECK(!devices.empty());
     }
 
     // The only case when devices can be empty is if the user has denied
     // permission.
     result = devices.empty() ? content::MEDIA_DEVICE_PERMISSION_DENIED
                              : content::MEDIA_DEVICE_OK;
   }
 
-  callback.Run(devices, result, ui.Pass());
+  callback.Run(devices, result, std::move(ui));
 }
 
 bool DesktopCaptureAccessHandler::SupportsStreamType(
     const content::MediaStreamType type,
     const extensions::Extension* extension) {
   return type == content::MEDIA_DESKTOP_VIDEO_CAPTURE ||
          type == content::MEDIA_DESKTOP_AUDIO_CAPTURE;
 }
 
 bool DesktopCaptureAccessHandler::CheckMediaAccessPermission(
     content::WebContents* web_contents,
     const GURL& security_origin,
     content::MediaStreamType type,
     const extensions::Extension* extension) {
   return false;
 }
 
 void DesktopCaptureAccessHandler::HandleRequest(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback,
     const extensions::Extension* extension) {
   content::MediaStreamDevices devices;
   scoped_ptr<content::MediaStreamUI> ui;
 
   if (request.video_type != content::MEDIA_DESKTOP_VIDEO_CAPTURE) {
-    callback.Run(devices, content::MEDIA_DEVICE_INVALID_STATE, ui.Pass());
+    callback.Run(devices, content::MEDIA_DEVICE_INVALID_STATE, std::move(ui));
     return;
   }
 
   // If the device id wasn't specified then this is a screen capture request
   // (i.e. chooseDesktopMedia() API wasn't used to generate device id).
   if (request.requested_video_device_id.empty()) {
     ProcessScreenCaptureAccessRequest(web_contents, request, callback,
                                       extension);
     return;
   }
@@ skipping 16 matching lines @@
                    ->GetDesktopStreamsRegistry()
                    ->RequestMediaForStreamId(request.requested_video_device_id,
                                              main_frame->GetProcess()->GetID(),
                                              main_frame->GetRoutingID(),
                                              request.security_origin,
                                              &original_extension_name);
   }
 
   // Received invalid device id.
   if (media_id.type == content::DesktopMediaID::TYPE_NONE) {
-    callback.Run(devices, content::MEDIA_DEVICE_INVALID_STATE, ui.Pass());
+    callback.Run(devices, content::MEDIA_DEVICE_INVALID_STATE, std::move(ui));
     return;
   }
 
   bool loopback_audio_supported = false;
 #if defined(USE_CRAS) || defined(OS_WIN)
   // Currently loopback audio capture is supported only on Windows and ChromeOS.
   loopback_audio_supported = true;
 #endif
 
   // Audio is only supported for screen capture streams.
   bool capture_audio =
       (media_id.type == content::DesktopMediaID::TYPE_SCREEN &&
        request.audio_type == content::MEDIA_DESKTOP_AUDIO_CAPTURE &&
        loopback_audio_supported);
 
   ui = GetDevicesForDesktopCapture(&devices, media_id, capture_audio, true,
                                    GetApplicationTitle(web_contents, extension),
                                    base::UTF8ToUTF16(original_extension_name));
 
-  callback.Run(devices, content::MEDIA_DEVICE_OK, ui.Pass());
+  callback.Run(devices, content::MEDIA_DEVICE_OK, std::move(ui));
 }
 
 void DesktopCaptureAccessHandler::UpdateMediaRequestState(
     int render_process_id,
     int render_frame_id,
     int page_request_id,
     content::MediaStreamType stream_type,
     content::MediaRequestState state) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Track desktop capture sessions.  Tracking is necessary to avoid unbalanced
@@ skipping 16 matching lines @@
         desktop_capture_sessions_.erase(it);
         break;
       }
     }
   }
 }
 
 bool DesktopCaptureAccessHandler::IsCaptureInProgress() {
   return desktop_capture_sessions_.size() > 0;
 }