Replace scoped_ptr with std::unique_ptr in //media/base.

media/base/media_keys.h

 // 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.
 
 #ifndef MEDIA_BASE_MEDIA_KEYS_H_
 #define MEDIA_BASE_MEDIA_KEYS_H_
 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "media/base/eme_constants.h"
 #include "media/base/media_export.h"
 #include "url/gurl.h"
 
 namespace base {
 class Time;
 }
 
 namespace media {
@@ skipping 68 matching lines @@
   // https://w3c.github.io/encrypted-media/#idl-def-MediaKeyMessageType
   enum MessageType {
     LICENSE_REQUEST,
     LICENSE_RENEWAL,
     LICENSE_RELEASE,
     MESSAGE_TYPE_MAX = LICENSE_RELEASE
   };
 
   // Provides a server certificate to be used to encrypt messages to the
   // license server.
-  virtual void SetServerCertificate(const std::vector<uint8_t>& certificate,
-                                    scoped_ptr<SimpleCdmPromise> promise) = 0;
+  virtual void SetServerCertificate(
+      const std::vector<uint8_t>& certificate,
+      std::unique_ptr<SimpleCdmPromise> promise) = 0;
 
   // Creates a session with |session_type|. Then generates a request with the
   // |init_data_type| and |init_data|.
   // Note:
   // 1. The session ID will be provided when the |promise| is resolved.
   // 2. The generated request should be returned through a SessionMessageCB,
   //    which must be AFTER the |promise| is resolved. Otherwise, the session ID
   //    in the callback will not be recognized.
   // 3. UpdateSession(), CloseSession() and RemoveSession() should only be
   //    called after the |promise| is resolved.
   virtual void CreateSessionAndGenerateRequest(
       SessionType session_type,
       EmeInitDataType init_data_type,
       const std::vector<uint8_t>& init_data,
-      scoped_ptr<NewSessionCdmPromise> promise) = 0;
+      std::unique_ptr<NewSessionCdmPromise> promise) = 0;
 
   // Loads a session with the |session_id| provided.
   // Note: UpdateSession(), CloseSession() and RemoveSession() should only be
   //       called after the |promise| is resolved.
   virtual void LoadSession(SessionType session_type,
                            const std::string& session_id,
-                           scoped_ptr<NewSessionCdmPromise> promise) = 0;
+                           std::unique_ptr<NewSessionCdmPromise> promise) = 0;
 
   // Updates a session specified by |session_id| with |response|.
   virtual void UpdateSession(const std::string& session_id,
                              const std::vector<uint8_t>& response,
-                             scoped_ptr<SimpleCdmPromise> promise) = 0;
+                             std::unique_ptr<SimpleCdmPromise> promise) = 0;
 
   // Closes the session specified by |session_id|. The CDM should resolve or
   // reject the |promise| when the call has been processed. This may be before
   // the session is closed. Once the session is closed, a SessionClosedCB must
   // also be called.
   virtual void CloseSession(const std::string& session_id,
-                            scoped_ptr<SimpleCdmPromise> promise) = 0;
+                            std::unique_ptr<SimpleCdmPromise> promise) = 0;
 
   // Removes stored session data associated with the session specified by
   // |session_id|.
   virtual void RemoveSession(const std::string& session_id,
-                             scoped_ptr<SimpleCdmPromise> promise) = 0;
+                             std::unique_ptr<SimpleCdmPromise> promise) = 0;
 
   // Returns the CdmContext associated with |this|. The returned CdmContext is
   // owned by |this| and the caller needs to make sure it is not used after
   // |this| is destructed.
   // Returns null if CdmContext is not supported. Instead the media player may
   // use the CDM via some platform specific method.
   // By default this method returns null.
   // TODO(xhwang): Convert all SetCdm() implementations to use CdmContext so
   // that this function should never return nullptr.
   virtual CdmContext* GetCdmContext();
@@ skipping 51 matching lines @@
 
 // Called when the CDM changes the expiration time of a session.
 // See http://w3c.github.io/encrypted-media/#update-expiration
 typedef base::Callback<void(const std::string& session_id,
                             const base::Time& new_expiry_time)>
     SessionExpirationUpdateCB;
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_MEDIA_KEYS_H_