Add a bool return value to media::Decryptor::GenerateKeyRequest().

webkit/media/crypto/proxy_decryptor.cc

 // Copyright (c) 2012 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 "webkit/media/crypto/proxy_decryptor.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 54 matching lines @@
     WebKit::WebFrame* web_frame)
     : client_(decryptor_client),
       web_media_player_client_(web_media_player_client),
       web_frame_(web_frame),
       stopped_(false) {
 }
 
 ProxyDecryptor::~ProxyDecryptor() {
 }
 
-void ProxyDecryptor::GenerateKeyRequest(const std::string& key_system,
+bool ProxyDecryptor::GenerateKeyRequest(const std::string& key_system,
                                         const uint8* init_data,
                                         int init_data_length) {
   // We do not support run-time switching of decryptors. GenerateKeyRequest()
   // only creates a new decryptor when |decryptor_| is not initialized.
   DVLOG(1) << "GenerateKeyRequest: key_system = " << key_system;
   if (!decryptor_.get()) {
     base::AutoLock auto_lock(lock_);
     decryptor_ = CreateDecryptor(key_system);
   }
 
   if (!decryptor_.get()) {
     client_->KeyError(key_system, "", media::Decryptor::kUnknownError, 0);
-    return;
+    return false;
   }
 
-  decryptor_->GenerateKeyRequest(key_system, init_data, init_data_length);
+  return decryptor_->GenerateKeyRequest(key_system,

[ddorwin, 2012/08/28 21:59:14]

For the meaning of the return value to be consistent (CDM is not established), I
think we need to destroy decryptor_ if this call fails. Otherwise, you could end
up with a plugin for one KS that can't be changed to another one with a future
GKR call.

+                                        init_data, init_data_length);
 }
 
 void ProxyDecryptor::AddKey(const std::string& key_system,
                             const uint8* key,
                             int key_length,
                             const uint8* init_data,
                             int init_data_length,
                             const std::string& session_id) {
   DVLOG(1) << "AddKey()";
 
@@ skipping 53 matching lines @@
       return;
     }
   }
 
   decryptor->Decrypt(encrypted, base::Bind(
       &ProxyDecryptor::OnBufferDecrypted, base::Unretained(this),
       base::MessageLoopProxy::current(), encrypted, decrypt_cb));
 }
 
 void ProxyDecryptor::Stop() {
-  DVLOG(1) << "AddKey()";
+  DVLOG(1) << "Stop()";
 
   std::vector<base::Closure> closures_to_run;
   {
     base::AutoLock auto_lock(lock_);
     if (decryptor_.get())
       decryptor_->Stop();
     stopped_ = true;
     std::swap(pending_decrypt_closures_, closures_to_run);
   }
 
@@ skipping 88 matching lines @@
         &ProxyDecryptor::DecryptOnMessageLoop, base::Unretained(this),
         message_loop_proxy, encrypted, decrypt_cb));
   }
   // TODO(xhwang): The same NeedKey may be fired multiple times here and also
   // in Decrypt(). While the spec says only one NeedKey should be fired. Leave
   // them as is since the spec about this may change.
   FireNeedKey(client_, encrypted);
 }
 
 }  // namespace webkit_media