Send multiple queries when DiscoverNewServices is called on a service watcher

chrome/utility/local_discovery/service_discovery_client_impl.cc

 // Copyright 2013 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 <utility>
 
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "chrome/utility/local_discovery/service_discovery_client_impl.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/record_rdata.h"
 
 namespace local_discovery {
 
 namespace {
 // TODO(noamsml): Make this configurable through the LocalDomainResolver
 // interface.
 const int kLocalDomainSecondAddressTimeoutMs = 100;
+
+const int kInitialRequeryTimeSeconds = 1;
+const int kMaxRequeryTimeSeconds = 2; // Time for last requery
 }
 
 ServiceDiscoveryClientImpl::ServiceDiscoveryClientImpl(
     net::MDnsClient* mdns_client) : mdns_client_(mdns_client) {
 }
 
 ServiceDiscoveryClientImpl::~ServiceDiscoveryClientImpl() {
 }
 
 scoped_ptr<ServiceWatcher> ServiceDiscoveryClientImpl::CreateServiceWatcher(
@@ skipping 36 matching lines @@
     ReadCachedServices();
 }
 
 ServiceWatcherImpl::~ServiceWatcherImpl() {
 }
 
 void ServiceWatcherImpl::DiscoverNewServices(bool force_update) {
   DCHECK(started_);
   if (force_update)
     services_.clear();
-  CreateTransaction(true /*network*/, false /*cache*/, force_update,
-                    &transaction_network_);
+  SendQuery(kInitialRequeryTimeSeconds, force_update);
 }
 
 void ServiceWatcherImpl::ReadCachedServices() {
   DCHECK(started_);
   CreateTransaction(false /*network*/, true /*cache*/, false /*force refresh*/,
                     &transaction_cache_);
 }
 
 bool ServiceWatcherImpl::CreateTransaction(
     bool network, bool cache, bool force_refresh,
@@ skipping 138 matching lines @@
       callback_.Run(UPDATE_REMOVED, service);
   }
 }
 
 void ServiceWatcherImpl::OnNsecRecord(const std::string& name,
                                       unsigned rrtype) {
   // Do nothing. It is an error for hosts to broadcast an NSEC record for PTR
   // on any name.
 }
 
+void ServiceWatcherImpl::ScheduleQuery(int timeout_seconds) {
+  if (timeout_seconds <= kMaxRequeryTimeSeconds) {
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&ServiceWatcherImpl::SendQuery,
+                   AsWeakPtr(),
+                   timeout_seconds * 2 /*next_timeout_seconds*/,
+                   false /*force_update*/),
+        base::TimeDelta::FromSeconds(timeout_seconds));
+  }
+}
+
+void ServiceWatcherImpl::SendQuery(int next_timeout_seconds,
+                                   bool force_update) {
+  CreateTransaction(true /*network*/, false /*cache*/, force_update,
+                    &transaction_network_);
+  ScheduleQuery(next_timeout_seconds);
+}
+
 ServiceResolverImpl::ServiceResolverImpl(
     const std::string& service_name,
     const ResolveCompleteCallback& callback,
     net::MDnsClient* mdns_client)
     : service_name_(service_name), callback_(callback),
       metadata_resolved_(false), address_resolved_(false),
       mdns_client_(mdns_client) {
 }
 
 void ServiceResolverImpl::StartResolving() {
@@ skipping 219 matching lines @@
 }
 
 void LocalDomainResolverImpl::SendResolvedAddresses() {
   transaction_a_.reset();
   transaction_aaaa_.reset();
   timeout_callback_.Cancel();
   callback_.Run(IsSuccess(), address_ipv4_, address_ipv6_);
 }
 
 }  // namespace local_discovery