Remove deprecated PPB_Messaging_1_1

ppapi/proxy/message_handler.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 "ppapi/proxy/message_handler.h"
 
 #include "ipc/ipc_message.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_message_loop_proxy.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/thunk/enter.h"
 
 namespace ppapi {
 namespace proxy {
 namespace {
 
 typedef void (*HandleMessageFunc)(PP_Instance, void*, const PP_Var*);
 typedef void (*HandleBlockingMessageFunc)(
     PP_Instance, void*, const PP_Var*, PP_Var*);
-typedef void (*HandleMessageFunc_0_1)(PP_Instance, void*, PP_Var);
-typedef PP_Var (*HandleBlockingMessageFunc_0_1)(PP_Instance, void*, PP_Var);
 
 void HandleMessageWrapper(HandleMessageFunc function,
                           PP_Instance instance,
                           void* user_data,
                           ScopedPPVar message_data) {
   CallWhileUnlocked(function, instance, user_data,
                     &message_data.get());
 }
 
 void HandleBlockingMessageWrapper(HandleBlockingMessageFunc function,
@@ skipping 11 matching lines @@
       function, instance, user_data, &message_data.get(), &result);
   MessageLoopResource::GetCurrent()->
       set_currently_handling_blocking_message(false);
   PpapiMsg_PPPMessageHandler_HandleBlockingMessage::WriteReplyParams(
       reply_msg.get(),
       SerializedVarReturnValue::Convert(dispatcher, result),
       true /* was_handled */);
   dispatcher->Send(reply_msg.release());
 }
 
-// TODO(dmichael): Remove the 0_1 verions; crbug.com/414398
-void HandleMessageWrapper_0_1(HandleMessageFunc_0_1 function,
-                              PP_Instance instance,
-                              void* user_data,
-                              ScopedPPVar message_data) {
-  CallWhileUnlocked(function, instance, user_data, message_data.get());
-}
-
-void HandleBlockingMessageWrapper_0_1(HandleBlockingMessageFunc_0_1 function,
-                                      PP_Instance instance,
-                                      void* user_data,
-                                      ScopedPPVar message_data,
-                                      scoped_ptr<IPC::Message> reply_msg) {
-  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
-  if (!dispatcher)
-    return;
-  MessageLoopResource::GetCurrent()->
-      set_currently_handling_blocking_message(true);
-  PP_Var return_value = CallWhileUnlocked(function,
-                                          instance,
-                                          user_data,
-                                          message_data.get());
-  MessageLoopResource::GetCurrent()->
-      set_currently_handling_blocking_message(false);
-  PpapiMsg_PPPMessageHandler_HandleBlockingMessage::WriteReplyParams(
-      reply_msg.get(),
-      SerializedVarReturnValue::Convert(dispatcher, return_value),
-      true /* was_handled */);
-  dispatcher->Send(reply_msg.release());
-}
-
 }  // namespace
 
 // static
 scoped_ptr<MessageHandler> MessageHandler::Create(
       PP_Instance instance,
       const PPP_MessageHandler_0_2* handler_if,
       void* user_data,
       PP_Resource message_loop,
       int32_t* error) {
   scoped_ptr<MessageHandler> result;
@@ skipping 17 matching lines @@
     *error = PP_ERROR_WRONG_THREAD;
     return result.Pass();
   }
 
   result.reset(new MessageHandler(
       instance, handler_if, user_data, message_loop_resource));
   *error = PP_OK;
   return result.Pass();
 }
 
-// CreateDeprecated is a near-exact copy of Create, but we'll just delete it
-// when 0.1 is deprecated, so need to get fancy to avoid code duplication.
-// TODO(dmichael) crbug.com/414398
-// static
-scoped_ptr<MessageHandler> MessageHandler::CreateDeprecated(
-      PP_Instance instance,
-      const PPP_MessageHandler_0_1_Deprecated* handler_if,
-      void* user_data,
-      PP_Resource message_loop,
-      int32_t* error) {
-  scoped_ptr<MessageHandler> result;
-  // The interface and all function pointers must be valid.
-  if (!handler_if ||
-      !handler_if->HandleMessage ||
-      !handler_if->HandleBlockingMessage ||
-      !handler_if->Destroy) {
-    *error = PP_ERROR_BADARGUMENT;
-    return result.Pass();
-  }
-  thunk::EnterResourceNoLock<thunk::PPB_MessageLoop_API>
-      enter_loop(message_loop, true);
-  if (enter_loop.failed()) {
-    *error = PP_ERROR_BADRESOURCE;
-    return result.Pass();
-  }
-  scoped_refptr<MessageLoopResource> message_loop_resource(
-      static_cast<MessageLoopResource*>(enter_loop.object()));
-  if (message_loop_resource->is_main_thread_loop()) {
-    *error = PP_ERROR_WRONG_THREAD;
-    return result.Pass();
-  }
-
-  result.reset(new MessageHandler(
-      instance, handler_if, user_data, message_loop_resource));
-  *error = PP_OK;
-  return result.Pass();
-}
-
 MessageHandler::~MessageHandler() {
   // It's possible the message_loop_proxy is NULL if that loop has been quit.
   // In that case, we unfortunately just can't call Destroy.
   if (message_loop_->message_loop_proxy().get()) {
     // The posted task won't have the proxy lock, but that's OK, it doesn't
     // touch any internal state; it's a direct call on the plugin's function.
-    if (handler_if_0_1_) {
-      message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
-          base::Bind(handler_if_0_1_->Destroy,
-                     instance_,
-                     user_data_));
-      return;
-    }
     message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
         base::Bind(handler_if_->Destroy,
                    instance_,
                    user_data_));
   }
 }
 
 bool MessageHandler::LoopIsValid() const {
   return !!message_loop_->message_loop_proxy().get();
 }
 
 void MessageHandler::HandleMessage(ScopedPPVar var) {
-  if (handler_if_0_1_) {
-    // TODO(dmichael): Remove this code path. crbug.com/414398
-    message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
-        RunWhileLocked(base::Bind(&HandleMessageWrapper_0_1,
-                                  handler_if_0_1_->HandleMessage,
-                                  instance_,
-                                  user_data_,
-                                  var)));
-    return;
-  }
   message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
       RunWhileLocked(base::Bind(&HandleMessageWrapper,
                                 handler_if_->HandleMessage,
                                 instance_,
                                 user_data_,
                                 var)));
 }
 
 void MessageHandler::HandleBlockingMessage(ScopedPPVar var,
                                            scoped_ptr<IPC::Message> reply_msg) {
-  if (handler_if_0_1_) {
-    // TODO(dmichael): Remove this code path. crbug.com/414398
-    message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
-        RunWhileLocked(base::Bind(&HandleBlockingMessageWrapper_0_1,
-                                  handler_if_0_1_->HandleBlockingMessage,
-                                  instance_,
-                                  user_data_,
-                                  var,
-                                  base::Passed(reply_msg.Pass()))));
-    return;
-  }
   message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
       RunWhileLocked(base::Bind(&HandleBlockingMessageWrapper,
                                 handler_if_->HandleBlockingMessage,
                                 instance_,
                                 user_data_,
                                 var,
                                 base::Passed(reply_msg.Pass()))));
 }
 
 MessageHandler::MessageHandler(
     PP_Instance instance,
     const PPP_MessageHandler_0_2* handler_if,
     void* user_data,
     scoped_refptr<MessageLoopResource> message_loop)
     : instance_(instance),
       handler_if_(handler_if),
-      handler_if_0_1_(NULL),
       user_data_(user_data),
       message_loop_(message_loop) {
 }
-
-MessageHandler::MessageHandler(
-    PP_Instance instance,
-    const PPP_MessageHandler_0_1_Deprecated* handler_if,
-    void* user_data,
-    scoped_refptr<MessageLoopResource> message_loop)
-    : instance_(instance),
-      handler_if_(NULL),
-      handler_if_0_1_(handler_if),
-      user_data_(user_data),
-      message_loop_(message_loop) {
-}
 
 }  // namespace proxy
 }  // namespace ppapi