Inject CanAddURLToHistory into TopSitesImpl

media/cdm/ppapi/external_clear_key/clear_key_cdm.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 "media/cdm/ppapi/external_clear_key/clear_key_cdm.h"
 
 #include <algorithm>
 #include <cstring>
 #include <sstream>
 #include <string>
@@ skipping 304 matching lines @@
   scoped_ptr<media::NewSessionCdmPromise> promise(
       new media::CdmCallbackPromise<std::string>(
           base::Bind(&ClearKeyCdm::OnSessionCreated,
                      base::Unretained(this),
                      promise_id),
           base::Bind(&ClearKeyCdm::OnPromiseFailed,
                      base::Unretained(this),
                      promise_id)));
   decryptor_.CreateSessionAndGenerateRequest(
       ConvertSessionType(session_type), ConvertInitDataType(init_data_type),
-      init_data, init_data_size, promise.Pass());
+      std::vector<uint8_t>(init_data, init_data + init_data_size),
+      promise.Pass());
 
   if (key_system_ == kExternalClearKeyFileIOTestKeySystem)
     StartFileIOTest();
 }
 
 // Loads a emulated stored session. Currently only |kLoadableSessionId|
 // (containing a |kLoadableSessionKey| for |kLoadableSessionKeyId|) is
 // supported.
 void ClearKeyCdm::LoadSession(uint32 promise_id,
                               cdm::SessionType session_type,
@@ skipping 18 matching lines @@
   DCHECK(session_id_for_emulated_loadsession_.empty());
 
   scoped_ptr<media::NewSessionCdmPromise> promise(
       new media::CdmCallbackPromise<std::string>(
           base::Bind(&ClearKeyCdm::OnSessionLoaded,
                      base::Unretained(this),
                      promise_id),
           base::Bind(&ClearKeyCdm::OnPromiseFailed,
                      base::Unretained(this),
                      promise_id)));
-  decryptor_.CreateSessionAndGenerateRequest(MediaKeys::TEMPORARY_SESSION,
-                                             EmeInitDataType::WEBM, NULL, 0,
-                                             promise.Pass());
+  decryptor_.CreateSessionAndGenerateRequest(
+      MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
+      std::vector<uint8_t>(), promise.Pass());
 }
 
 void ClearKeyCdm::UpdateSession(uint32 promise_id,
                                 const char* session_id,
                                 uint32_t session_id_length,
                                 const uint8* response,
                                 uint32 response_size) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(session_id, session_id_length);
 
   // If updating the loadable session, use the actual session id generated.
   if (web_session_str == std::string(kLoadableSessionId))
     web_session_str = session_id_for_emulated_loadsession_;
 
   scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
       base::Bind(&ClearKeyCdm::OnPromiseResolved, base::Unretained(this),
                  promise_id),
       base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                  promise_id)));
   decryptor_.UpdateSession(
-      web_session_str, response, response_size, promise.Pass());
+      web_session_str, std::vector<uint8_t>(response, response + response_size),
+      promise.Pass());
 
   if (!renewal_timer_set_) {
     ScheduleNextRenewal();
     renewal_timer_set_ = true;
   }
 }
 
 void ClearKeyCdm::CloseSession(uint32 promise_id,
                                const char* session_id,
                                uint32_t session_id_length) {
@@ skipping 316 matching lines @@
 void ClearKeyCdm::LoadLoadableSession() {
   std::string jwk_set = GenerateJWKSet(kLoadableSessionKey,
                                        sizeof(kLoadableSessionKey),
                                        kLoadableSessionKeyId,
                                        sizeof(kLoadableSessionKeyId) - 1);
   scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
       base::Bind(&ClearKeyCdm::OnLoadSessionUpdated, base::Unretained(this)),
       base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                  promise_id_for_emulated_loadsession_)));
   decryptor_.UpdateSession(session_id_for_emulated_loadsession_,
-                           reinterpret_cast<const uint8*>(jwk_set.data()),
-                           jwk_set.size(),
+                           std::vector<uint8_t>(jwk_set.begin(), jwk_set.end()),
                            promise.Pass());
 }
 
 void ClearKeyCdm::OnSessionMessage(const std::string& session_id,
                                    MediaKeys::MessageType message_type,
                                    const std::vector<uint8>& message,
                                    const GURL& legacy_destination_url) {
   DVLOG(1) << "OnSessionMessage: " << message.size();
 
   // Ignore the message when we are waiting to update the loadable session.
@@ skipping 188 matching lines @@
 void ClearKeyCdm::OnFileIOTestComplete(bool success) {
   DVLOG(1) << __FUNCTION__ << ": " << success;
   std::string message = GetFileIOTestResultMessage(success);
   host_->OnSessionMessage(last_session_id_.data(), last_session_id_.length(),
                           cdm::kLicenseRequest, message.data(),
                           message.length(), NULL, 0);
   file_io_test_runner_.reset();
 }
 
 }  // namespace media