ppapi/proxy/host_resolver_resource_base.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/proxy/host_resolver_resource_base.h"
   6
   7 #include "ppapi/c/pp_errors.h"
   8 #include "ppapi/proxy/net_address_resource.h"
   9 #include "ppapi/proxy/ppapi_messages.h"
  10 #include "ppapi/shared_impl/tracked_callback.h"
  11 #include "ppapi/shared_impl/var.h"
  12
  13 namespace ppapi {
  14 namespace proxy {
  15
  16 namespace {
  17
  18 int32_t ConvertPPError(int32_t pp_error, bool private_api) {
  19   // The private API doesn't return network-specific error codes or
  20   // PP_ERROR_NOACCESS. In order to preserve the behavior, we convert those to
  21   // PP_ERROR_FAILED.
  22   // TODO(yzshen): Consider defining ranges for different kinds of PP_Error
  23   // codes, so that we can detect network-specific error codes in a better way.
  24   if (private_api &&
  25       (pp_error <= PP_ERROR_CONNECTION_CLOSED ||
  26        pp_error == PP_ERROR_NOACCESS)) {
  27     return PP_ERROR_FAILED;
  28   }
  29
  30   return pp_error;
  31 }
  32
  33 }  // namespace
  34
  35 HostResolverResourceBase::HostResolverResourceBase(Connection connection,
  36                                                    PP_Instance instance,
  37                                                    bool private_api)
  38     : PluginResource(connection, instance),
  39       private_api_(private_api),
  40       allow_get_results_(false) {
  41   if (private_api)
  42     SendCreate(BROWSER, PpapiHostMsg_HostResolver_CreatePrivate());
  43   else
  44     SendCreate(BROWSER, PpapiHostMsg_HostResolver_Create());
  45 }
  46
  47 HostResolverResourceBase::~HostResolverResourceBase() {
  48 }
  49
  50 int32_t HostResolverResourceBase::ResolveImpl(
  51     const char* host,
  52     uint16_t port,
  53     const PP_HostResolver_Private_Hint* hint,
  54     scoped_refptr<TrackedCallback> callback) {
  55   allow_get_results_ = false;
  56   if (!host || !hint)
  57     return PP_ERROR_BADARGUMENT;
  58   if (ResolveInProgress())
  59     return PP_ERROR_INPROGRESS;
  60
  61   resolve_callback_ = callback;
  62
  63   HostPortPair host_port;
  64   host_port.host = host;
  65   host_port.port = port;
  66
  67   SendResolve(host_port, hint);
  68   return PP_OK_COMPLETIONPENDING;
  69 }
  70
  71 PP_Var HostResolverResourceBase::GetCanonicalNameImpl() {
  72   if (!allow_get_results_)
  73     return PP_MakeUndefined();
  74
  75   return StringVar::StringToPPVar(canonical_name_);
  76 }
  77
  78 uint32_t HostResolverResourceBase::GetSizeImpl() {
  79   if (!allow_get_results_)
  80     return 0;
  81   return static_cast<uint32_t>(net_address_list_.size());
  82 }
  83
  84 scoped_refptr<NetAddressResource> HostResolverResourceBase::GetNetAddressImpl(
  85     uint32_t index) {
  86   if (!allow_get_results_ || index >= GetSizeImpl())
  87     return scoped_refptr<NetAddressResource>();
  88
  89   return net_address_list_[index];
  90 }
  91
  92 void HostResolverResourceBase::OnPluginMsgResolveReply(
  93     const ResourceMessageReplyParams& params,
  94     const std::string& canonical_name,
  95     const std::vector<PP_NetAddress_Private>& net_address_list) {
  96   if (params.result() == PP_OK) {
  97     allow_get_results_ = true;
  98     canonical_name_ = canonical_name;
  99
 100     net_address_list_.clear();
 101     for (std::vector<PP_NetAddress_Private>::const_iterator iter =
 102              net_address_list.begin();
 103          iter != net_address_list.end();
 104          ++iter) {
 105       net_address_list_.push_back(
 106           new NetAddressResource(connection(), pp_instance(), *iter));
 107     }
 108   } else {
 109     canonical_name_.clear();
 110     net_address_list_.clear();
 111   }
 112   resolve_callback_->Run(ConvertPPError(params.result(), private_api_));
 113 }
 114
 115 void HostResolverResourceBase::SendResolve(
 116     const HostPortPair& host_port,
 117     const PP_HostResolver_Private_Hint* hint) {
 118   PpapiHostMsg_HostResolver_Resolve msg(host_port, *hint);
 119   Call<PpapiPluginMsg_HostResolver_ResolveReply>(
 120       BROWSER,
 121       msg,
 122       base::Bind(&HostResolverResourceBase::OnPluginMsgResolveReply,
 123                  base::Unretained(this)));
 124 }
 125
 126 bool HostResolverResourceBase::ResolveInProgress() const {
 127   return TrackedCallback::IsPending(resolve_callback_);
 128 }
 129
 130 }  // namespace proxy
 131 }  // namespace ppapi