Inject CanAddURLToHistory into TopSitesImpl

media/cdm/proxy_decryptor.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/proxy_decryptor.h"
 
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
+#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "media/base/cdm_callback_promise.h"
 #include "media/base/cdm_factory.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/key_systems.h"
 #include "media/base/media_permission.h"
 #include "media/cdm/json_web_key.h"
 #include "media/cdm/key_system_names.h"
 
 namespace media {
@@ skipping 187 matching lines @@
     EmeInitDataType init_data_type,
     const std::vector<uint8>& init_data,
     scoped_ptr<NewSessionCdmPromise> promise,
     bool granted) {
   // ProxyDecryptor is only used by Prefixed EME, where RequestPermission() is
   // only for triggering the permission UI. Later CheckPermission() will be
   // called (e.g. in PlatformVerificationFlow on ChromeOS; in BrowserCdmManager
   // on Android) and the permission status will be evaluated then.
   DVLOG_IF(1, !granted) << "Permission request rejected.";
 
-  media_keys_->CreateSessionAndGenerateRequest(
-      session_type, init_data_type, vector_as_array(&init_data),
-      init_data.size(), promise.Pass());
+  media_keys_->CreateSessionAndGenerateRequest(session_type, init_data_type,
+                                               init_data, promise.Pass());
 }
 
 void ProxyDecryptor::AddKey(const uint8* key,
                             int key_length,
                             const uint8* init_data,
                             int init_data_length,
                             const std::string& session_id) {
   DVLOG(1) << "AddKey()";
 
   if (!media_keys_) {
@@ skipping 32 matching lines @@
     if (!init_data) {
       static const uint8 kDummyInitData[1] = {0};
       init_data = kDummyInitData;
       init_data_length = arraysize(kDummyInitData);
     }
 
     std::string jwk =
         GenerateJWKSet(key, key_length, init_data, init_data_length);
     DCHECK(!jwk.empty());
     media_keys_->UpdateSession(new_session_id,
-                               reinterpret_cast<const uint8*>(jwk.data()),
-                               jwk.size(), promise.Pass());
+                               std::vector<uint8_t>(jwk.begin(), jwk.end()),
+                               promise.Pass());
     return;
   }
 
-  media_keys_->UpdateSession(new_session_id, key, key_length, promise.Pass());
+  media_keys_->UpdateSession(new_session_id,
+                             std::vector<uint8_t>(key, key + key_length),
+                             promise.Pass());
 }
 
 void ProxyDecryptor::CancelKeyRequest(const std::string& session_id) {
   DVLOG(1) << "CancelKeyRequest()";
 
   if (!media_keys_) {
     OnLegacySessionError(std::string(), MediaKeys::INVALID_STATE_ERROR, 0,
                          "CDM is not available.");
     return;
   }
@@ skipping 96 matching lines @@
   bool is_persistent =
       session_type == PersistentSession || session_type == LoadSession;
   active_sessions_.insert(std::make_pair(session_id, is_persistent));
 
   // For LoadSession(), generate the KeyAdded event.
   if (session_type == LoadSession)
     GenerateKeyAdded(session_id);
 }
 
 }  // namespace media