NaCl cleanup: Remove SrpcParams and SrpcClient, which are unused now

components/nacl/renderer/plugin/nacl_subprocess.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 "components/nacl/renderer/plugin/nacl_subprocess.h"
 
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <sstream>
 
 #include "components/nacl/renderer/plugin/plugin_error.h"
-#include "components/nacl/renderer/plugin/srpc_params.h"
-#include "native_client/src/shared/srpc/nacl_srpc.h"
 
 namespace plugin {
 
 NaClSubprocess::NaClSubprocess(const std::string& description,
-                               ServiceRuntime* service_runtime,
-                               SrpcClient* srpc_client)
+                               ServiceRuntime* service_runtime)
   : description_(description),
-    service_runtime_(service_runtime),
-    srpc_client_(srpc_client) {
+    service_runtime_(service_runtime) {
 }
 
 std::string NaClSubprocess::detailed_description() const {
   std::stringstream ss;
   ss << description()
      << "={ this=" << static_cast<const void*>(this)
-     << ", srpc_client=" << static_cast<void*>(srpc_client_.get())
      << ", service_runtime=" << static_cast<void*>(service_runtime_.get())
      << " }";
   return ss.str();
 }
 
 // Shutdown the socket connection and service runtime, in that order.
 void NaClSubprocess::Shutdown() {
-  srpc_client_.reset(NULL);
   if (service_runtime_.get() != NULL) {
     service_runtime_->Shutdown();
     service_runtime_.reset(NULL);
   }
 }
 
 NaClSubprocess::~NaClSubprocess() {
   Shutdown();
 }
 
-bool NaClSubprocess::StartSrpcServices() {
-  srpc_client_.reset(service_runtime_->SetupAppChannel());
-  return NULL != srpc_client_.get();
-}
-
-bool NaClSubprocess::InvokeSrpcMethod(const std::string& method_name,
-                                      const std::string& input_signature,
-                                      SrpcParams* params,
-                                      ...) {
-  va_list vl;
-  va_start(vl, params);
-  bool result = VInvokeSrpcMethod(method_name, input_signature, params, vl);
-  va_end(vl);
-  return result;
-}
-
-bool NaClSubprocess::VInvokeSrpcMethod(const std::string& method_name,
-                                       const std::string& input_signature,
-                                       SrpcParams* params,
-                                       va_list vl) {
-  if (NULL == srpc_client_.get()) {
-    PLUGIN_PRINTF(("VInvokeSrpcMethod (no srpc_client_)\n"));
-    return false;
-  }
-  if (!srpc_client_->HasMethod(method_name)) {
-    PLUGIN_PRINTF(("VInvokeSrpcMethod (no %s method found)\n",
-                   method_name.c_str()));
-    return false;
-  }
-  if (!srpc_client_->InitParams(method_name, params)) {
-    PLUGIN_PRINTF(("VInvokeSrpcMethod (InitParams failed)\n"));
-    return false;
-  }
-  // Marshall inputs.
-  for (size_t i = 0; i < input_signature.length(); ++i) {
-    char c = input_signature[i];
-    // Only handle the limited number of SRPC types used for PNaCl.
-    // Add more as needed.
-    switch (c) {
-      default:
-        PLUGIN_PRINTF(("PnaclSrpcLib::InvokeSrpcMethod unhandled type: %c\n",
-                       c));
-        return false;
-      case NACL_SRPC_ARG_TYPE_BOOL: {
-        int input = va_arg(vl, int);
-        params->ins()[i]->u.bval = input;
-        break;
-      }
-      case NACL_SRPC_ARG_TYPE_DOUBLE: {
-        double input = va_arg(vl, double);
-        params->ins()[i]->u.dval = input;
-        break;
-      }
-      case NACL_SRPC_ARG_TYPE_CHAR_ARRAY: {
-        // SrpcParam's destructor *should* free the allocated array
-        const char* orig_arr = va_arg(vl, const char*);
-        size_t len = va_arg(vl, size_t);
-        char* input = (char *)malloc(len);
-        if (!input) {
-          PLUGIN_PRINTF(("VInvokeSrpcMethod (allocation failure)\n"));
-          return false;
-        }
-        memcpy(input, orig_arr, len);
-        params->ins()[i]->arrays.carr = input;
-        params->ins()[i]->u.count = static_cast<nacl_abi_size_t>(len);
-        break;
-      }
-      case NACL_SRPC_ARG_TYPE_HANDLE: {
-        NaClSrpcImcDescType input = va_arg(vl, NaClSrpcImcDescType);
-        params->ins()[i]->u.hval = input;
-        break;
-      }
-      case NACL_SRPC_ARG_TYPE_INT: {
-        int32_t input = va_arg(vl, int32_t);
-        params->ins()[i]->u.ival = input;
-        break;
-      }
-      case NACL_SRPC_ARG_TYPE_LONG: {
-        int64_t input = va_arg(vl, int64_t);
-        params->ins()[i]->u.lval = input;
-        break;
-      }
-      case NACL_SRPC_ARG_TYPE_STRING: {
-        // SrpcParam's destructor *should* free the dup'ed string.
-        const char* orig_str = va_arg(vl, const char*);
-        char* input = strdup(orig_str);
-        if (!input) {
-          PLUGIN_PRINTF(("VInvokeSrpcMethod (allocation failure)\n"));
-          return false;
-        }
-        params->ins()[i]->arrays.str = input;
-        break;
-      }
-    }
-  }
-  return srpc_client_->Invoke(method_name, params);
-}
-
 }  // namespace plugin