Add IDL capability to json_schema_compiler.

chrome/browser/extensions/api/dns/dns_api.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 "chrome/browser/extensions/api/dns/dns_api.h"
 
 #include "base/bind.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/io_thread.h"
+#include "chrome/common/extensions/api/experimental.dns.h"

[asargent_no_longer_on_chrome, 2012/03/06 22:27:57]

This experimental.dns.h file gets auto-generated during build time right? Does
it literally end up at src/chrome/common/extensions/api/experimental.dns.h, or
is it somewhere in $BUILDDIR?

[miket_OOO, 2012/03/07 00:23:01]

Don't worry! If you take a look at http://codereview.chromium.org/9359040/,
particularly build/apiidlc.gypi, then you will see that generated files are
emitted into a subdirectory of $SHARED_INTERMEDIATE_DIR (e.g.,
out/Debug/obj/gen/foo/bar/baz). Though that CL wasn't checked in, Chris did
roughly the same thing in the code that this CL is based on.

The tricky part was getting the compiler to see those generated files; the
"direct_dependent_settings" item in the .gypi is what makes what work (again,
that's in the other CL).

 #include "content/public/browser/browser_thread.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 
 using content::BrowserThread;
+using namespace extensions::api::experimental;
 
 namespace extensions {
 
-const char kAddressKey[] = "address";
-const char kResultCodeKey[] = "resultCode";
-
 // static
 net::HostResolver* DNSResolveFunction::host_resolver_for_testing;
 
 DNSResolveFunction::DNSResolveFunction()
     : response_(false),
       io_thread_(g_browser_process->io_thread()),
       capturing_bound_net_log_(new net::CapturingBoundNetLog(
           net::CapturingNetLog::kUnbounded)),
       request_handle_(new net::HostResolver::RequestHandle()),
       addresses_(new net::AddressList) {
 }
 
 DNSResolveFunction::~DNSResolveFunction() {
 }
 
 // static
 void DNSResolveFunction::set_host_resolver_for_testing(
     net::HostResolver* host_resolver_for_testing_param) {
   host_resolver_for_testing = host_resolver_for_testing_param;
 }
 
 bool DNSResolveFunction::RunImpl() {
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &hostname_));
+  scoped_ptr<Resolve::Params> params(Resolve::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  hostname_ = params->hostname;
+
   bool result = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&DNSResolveFunction::WorkOnIOThread, this));
   DCHECK(result);
   return true;
 }
 
 void DNSResolveFunction::WorkOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
@@ skipping 14 matching lines @@
       request_handle_.get(), capturing_bound_net_log_->bound());
 
   // Balanced in OnLookupFinished.
   AddRef();
 
   if (resolve_result != net::ERR_IO_PENDING)
     OnLookupFinished(resolve_result);
 }
 
 void DNSResolveFunction::OnLookupFinished(int resolve_result) {
-  DictionaryValue* api_result = new DictionaryValue();
-  api_result->SetInteger(kResultCodeKey, resolve_result);
+
+  scoped_ptr<ResolveCallbackResolveInfo> resolve_info(
+      new ResolveCallbackResolveInfo());
+  resolve_info->result_code = resolve_result;
   if (resolve_result == net::OK) {
     const struct addrinfo* head = addresses_->head();
     DCHECK(head);
-    api_result->SetString(kAddressKey, net::NetAddressToString(head));
+    resolve_info->address.reset(
+        new std::string(net::NetAddressToString(head)));
   }
-  result_.reset(api_result);
+  result_.reset(Resolve::Result::Create(*resolve_info));
   response_ = true;
 
   bool post_task_result = BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DNSResolveFunction::RespondOnUIThread, this));
   DCHECK(post_task_result);
 
   Release();  // Added in WorkOnIOThread().
 }
 
 void DNSResolveFunction::RespondOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   SendResponse(response_);
 }
 
 }  // namespace extensions