PPB_HostResolver_Private is switched to the new Pepper proxy.

content/browser/renderer_host/pepper/pepper_host_resolver_private_shared.cc

Index: content/browser/renderer_host/pepper/pepper_host_resolver_private_shared.cc
diff --git a/content/browser/renderer_host/pepper/pepper_host_resolver_private_shared.cc b/content/browser/renderer_host/pepper/pepper_host_resolver_private_shared.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8ca2a1dca9c63c474f54c81e2633cbab40d6a039
--- /dev/null
+++ b/content/browser/renderer_host/pepper/pepper_host_resolver_private_shared.cc
@@ -0,0 +1,116 @@
+// 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  "content/browser/renderer_host/pepper/pepper_host_resolver_private_shared.h"
+
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "content/browser/renderer_host/pepper/pepper_lookup_request.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/base/address_list.h"
+#include "net/base/host_resolver.h"
+#include "ppapi/c/private/ppb_host_resolver_private.h"
+#include "ppapi/c/private/ppb_net_address_private.h"
+#include "ppapi/shared_impl/private/net_address_private_impl.h"
+#include "ppapi/shared_impl/private/ppb_host_resolver_shared.h"
+
+namespace {
+
+void PrepareRequestInfo(const PP_HostResolver_Private_Hint& hint,
+                        net::HostResolver::RequestInfo* request_info) {
+  DCHECK(request_info);
+
+  net::AddressFamily address_family;
+  switch (hint.family) {
+    case PP_NETADDRESSFAMILY_IPV4:
+      address_family = net::ADDRESS_FAMILY_IPV4;
+      break;
+    case PP_NETADDRESSFAMILY_IPV6:
+      address_family = net::ADDRESS_FAMILY_IPV6;
+      break;
+    default:
+      address_family = net::ADDRESS_FAMILY_UNSPECIFIED;
+  }
+  request_info->set_address_family(address_family);
+
+  net::HostResolverFlags host_resolver_flags = 0;
+  if (hint.flags & PP_HOST_RESOLVER_FLAGS_CANONNAME)
+    host_resolver_flags |= net::HOST_RESOLVER_CANONNAME;
+  if (hint.flags & PP_HOST_RESOLVER_FLAGS_LOOPBACK_ONLY)
+    host_resolver_flags |= net::HOST_RESOLVER_LOOPBACK_ONLY;
+  request_info->set_host_resolver_flags(host_resolver_flags);
+}
+
+void CreateNetAddressListFromAddressList(
+    const net::AddressList& list,
+    std::vector<PP_NetAddress_Private>* net_address_list) {
+  PP_NetAddress_Private address;
+  for (size_t i = 0; i < list.size(); ++i) {
+    if (!ppapi::NetAddressPrivateImpl::IPEndPointToNetAddress(list[i].address(),
+                                                              list[i].port(),
+                                                              &address)) {
+      net_address_list->clear();
+      return;
+    }
+    net_address_list->push_back(address);
+  }
+}
+
+}  // namespace
+
+namespace content {
+
+PepperHostResolverPrivateShared::PepperHostResolverPrivateShared()
+    : weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+}
+
+PepperHostResolverPrivateShared::~PepperHostResolverPrivateShared() {
+}
+
+void PepperHostResolverPrivateShared::HostResolverResolve(
+    const BoundInfo& bound_info,
+    const ppapi::HostPortPair& host_port,
+    const PP_HostResolver_Private_Hint& hint) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (!GetHostResolver()) {
+    HostResolverSendError(bound_info);
+    return;
+  }
+
+  scoped_ptr<BoundInfo> info(new BoundInfo(bound_info));
+
+  net::HostResolver::RequestInfo request_info(
+      net::HostPortPair(host_port.host, host_port.port));
+  PrepareRequestInfo(hint, &request_info);
+
+  // The lookup request will delete itself on completion.
+  PepperLookupRequest<BoundInfo>* lookup_request =
+      new PepperLookupRequest<BoundInfo>(
+          GetHostResolver(),
+          request_info,
+          info.release(),
+          base::Bind(&PepperHostResolverPrivateShared::OnLookupFinished,
+                     weak_factory_.GetWeakPtr()));
+  lookup_request->Start();
+}
+
+void PepperHostResolverPrivateShared::OnLookupFinished(
+    int result,
+    const net::AddressList& addresses,
+    const BoundInfo& bound_info) {
+  if (result != net::OK) {
+    HostResolverSendError(bound_info);
+  } else {
+    const std::string& canonical_name = addresses.canonical_name();
+    std::vector<PP_NetAddress_Private> net_address_list;
+    CreateNetAddressListFromAddressList(addresses, &net_address_list);
+    if (net_address_list.size() == 0)
+      HostResolverSendError(bound_info);
+    else
+      HostResolverSendReply(true, canonical_name, net_address_list, bound_info);
+  }
+}
+
+}  // namespace content