Inject CanAddURLToHistory into TopSitesImpl

media/blink/cdm_session_adapter.cc

 // Copyright 2014 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/blink/cdm_session_adapter.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
@@ skipping 32 matching lines @@
       security_origin,
       base::Bind(&CdmSessionAdapter::OnSessionMessage, weak_this),
       base::Bind(&CdmSessionAdapter::OnSessionClosed, weak_this),
       base::Bind(&CdmSessionAdapter::OnLegacySessionError, weak_this),
       base::Bind(&CdmSessionAdapter::OnSessionKeysChange, weak_this),
       base::Bind(&CdmSessionAdapter::OnSessionExpirationUpdate, weak_this),
       base::Bind(&CdmSessionAdapter::OnCdmCreated, this, key_system, result));
 }
 
 void CdmSessionAdapter::SetServerCertificate(
-    const uint8* server_certificate,
-    int server_certificate_length,
+    const std::vector<uint8_t>& certificate,
     scoped_ptr<SimpleCdmPromise> promise) {
-  cdm_->SetServerCertificate(server_certificate, server_certificate_length,
-                             promise.Pass());
+  cdm_->SetServerCertificate(certificate, promise.Pass());
 }
 
 WebContentDecryptionModuleSessionImpl* CdmSessionAdapter::CreateSession() {
   return new WebContentDecryptionModuleSessionImpl(this);
 }
 
 bool CdmSessionAdapter::RegisterSession(
     const std::string& session_id,
     base::WeakPtr<WebContentDecryptionModuleSessionImpl> session) {
   // If this session ID is already registered, don't register it again.
   if (ContainsKey(sessions_, session_id))
     return false;
 
   sessions_[session_id] = session;
   return true;
 }
 
 void CdmSessionAdapter::UnregisterSession(const std::string& session_id) {
   DCHECK(ContainsKey(sessions_, session_id));
   sessions_.erase(session_id);
 }
 
 void CdmSessionAdapter::InitializeNewSession(
     EmeInitDataType init_data_type,
-    const uint8* init_data,
-    int init_data_length,
+    const std::vector<uint8_t>& init_data,
     MediaKeys::SessionType session_type,
     scoped_ptr<NewSessionCdmPromise> promise) {
   cdm_->CreateSessionAndGenerateRequest(session_type, init_data_type, init_data,
-                                        init_data_length, promise.Pass());
+                                        promise.Pass());
 }
 
 void CdmSessionAdapter::LoadSession(MediaKeys::SessionType session_type,
                                     const std::string& session_id,
                                     scoped_ptr<NewSessionCdmPromise> promise) {
   cdm_->LoadSession(session_type, session_id, promise.Pass());
 }
 
 void CdmSessionAdapter::UpdateSession(const std::string& session_id,
-                                      const uint8* response,
-                                      int response_length,
+                                      const std::vector<uint8_t>& response,
                                       scoped_ptr<SimpleCdmPromise> promise) {
-  cdm_->UpdateSession(session_id, response, response_length, promise.Pass());
+  cdm_->UpdateSession(session_id, response, promise.Pass());
 }
 
 void CdmSessionAdapter::CloseSession(const std::string& session_id,
                                      scoped_ptr<SimpleCdmPromise> promise) {
   cdm_->CloseSession(session_id, promise.Pass());
 }
 
 void CdmSessionAdapter::RemoveSession(const std::string& session_id,
                                       scoped_ptr<SimpleCdmPromise> promise) {
   cdm_->RemoveSession(session_id, promise.Pass());
@@ skipping 28 matching lines @@
       kMediaEME + GetKeySystemNameForUMA(key_system) + kDot;
   cdm_ = cdm.Pass();
 
   result.completeWithContentDecryptionModule(
       new WebContentDecryptionModuleImpl(this));
 }
 
 void CdmSessionAdapter::OnSessionMessage(
     const std::string& session_id,
     MediaKeys::MessageType message_type,
-    const std::vector<uint8>& message,
+    const std::vector<uint8_t>& message,
     const GURL& /* legacy_destination_url */) {
   WebContentDecryptionModuleSessionImpl* session = GetSession(session_id);
   DLOG_IF(WARNING, !session) << __FUNCTION__ << " for unknown session "
                              << session_id;
   if (session)
     session->OnSessionMessage(message_type, message);
 }
 
 void CdmSessionAdapter::OnSessionKeysChange(const std::string& session_id,
                                             bool has_additional_usable_key,
@@ skipping 20 matching lines @@
   WebContentDecryptionModuleSessionImpl* session = GetSession(session_id);
   DLOG_IF(WARNING, !session) << __FUNCTION__ << " for unknown session "
                              << session_id;
   if (session)
     session->OnSessionClosed();
 }
 
 void CdmSessionAdapter::OnLegacySessionError(
     const std::string& session_id,
     MediaKeys::Exception exception_code,
-    uint32 system_code,
+    uint32_t system_code,
     const std::string& error_message) {
   // Error events not used by unprefixed EME.
   // TODO(jrummell): Remove when prefixed EME removed.
 }
 
 WebContentDecryptionModuleSessionImpl* CdmSessionAdapter::GetSession(
     const std::string& session_id) {
   // Since session objects may get garbage collected, it is possible that there
   // are events coming back from the CDM and the session has been unregistered.
   // We can not tell if the CDM is firing events at sessions that never existed.
   SessionMap::iterator session = sessions_.find(session_id);
   return (session != sessions_.end()) ? session->second.get() : NULL;
 }
 
 }  // namespace media