Add the ability for MDnsListener to actively refresh records

net/dns/mdns_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 "net/dns/mdns_client_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/time/default_clock.h"
 #include "net/base/dns_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/rand_callback.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/record_rdata.h"
 #include "net/udp/datagram_socket.h"
 
 // TODO(gene): Remove this temporary method of disabling NSEC support once it
 // becomes clear whether this feature should be
 // supported. http://crbug.com/255232
 #define ENABLE_NSEC
 
 namespace net {
 
 namespace {
 
 const unsigned MDnsTransactionTimeoutSeconds = 3;
+// The fractions of the record's original TTL after which an active listener
+// (one that had |SetActiveRefresh(true)| called) will send a query to refresh
+// its cache. This happens both at 85% of the original TTL and again at 95% of
+// the original TTL.
+const double kListenerRefreshRatio1 = 0.85;
+const double kListenerRefreshRatio2 = 0.95;
+const unsigned kMillisecondsPerSecond = 1000;
 
 }  // namespace
 
 void MDnsSocketFactoryImpl::CreateSockets(
     ScopedVector<DatagramServerSocket>* sockets) {
   InterfaceIndexFamilyList interfaces(GetMDnsInterfacesToBind());
   for (size_t i = 0; i < interfaces.size(); ++i) {
     DCHECK(interfaces[i].second == net::ADDRESS_FAMILY_IPV4 ||
            interfaces[i].second == net::ADDRESS_FAMILY_IPV6);
     scoped_ptr<DatagramServerSocket> socket(
@@ skipping 146 matching lines @@
 
   return connection_->Send(query.io_buffer(), query.io_buffer()->size());
 }
 
 void MDnsClientImpl::Core::HandlePacket(DnsResponse* response,
                                         int bytes_read) {
   unsigned offset;
   // Note: We store cache keys rather than record pointers to avoid
   // erroneous behavior in case a packet contains multiple exclusive
   // records with the same type and name.
-  std::map<MDnsCache::Key, MDnsListener::UpdateType> update_keys;
+  std::map<MDnsCache::Key, MDnsCache::UpdateType> update_keys;
 
   if (!response->InitParseWithoutQuery(bytes_read)) {
     LOG(WARNING) << "Could not understand an mDNS packet.";
     return;  // Message is unreadable.
   }
 
   // TODO(noamsml): duplicate query suppression.
   if (!(response->flags() & dns_protocol::kFlagResponse))
     return;  // Message is a query. ignore it.
 
@@ skipping 22 matching lines @@
       LOG(WARNING) << "Received an mDNS record with non-IN class. Ignoring.";
       continue;  // Ignore all records not in the IN class.
     }
 
     MDnsCache::Key update_key = MDnsCache::Key::CreateFor(record.get());
     MDnsCache::UpdateType update = cache_.UpdateDnsRecord(record.Pass());
 
     // Cleanup time may have changed.
     ScheduleCleanup(cache_.next_expiration());
 
-    if (update != MDnsCache::NoChange) {
-      MDnsListener::UpdateType update_external;
-
-      switch (update) {
-        case MDnsCache::RecordAdded:
-          update_external = MDnsListener::RECORD_ADDED;
-          break;
-        case MDnsCache::RecordChanged:
-          update_external = MDnsListener::RECORD_CHANGED;
-          break;
-        case MDnsCache::NoChange:
-        default:
-          NOTREACHED();
-          // Dummy assignment to suppress compiler warning.
-          update_external = MDnsListener::RECORD_CHANGED;
-          break;
-      }
-
-      update_keys.insert(std::make_pair(update_key, update_external));
-    }
+    update_keys.insert(std::make_pair(update_key, update));
   }
 
-  for (std::map<MDnsCache::Key, MDnsListener::UpdateType>::iterator i =
+  for (std::map<MDnsCache::Key, MDnsCache::UpdateType>::iterator i =
            update_keys.begin(); i != update_keys.end(); i++) {
     const RecordParsed* record = cache_.LookupKey(i->first);
     if (!record)
       continue;
 
     if (record->type() == dns_protocol::kTypeNSEC) {
 #if defined(ENABLE_NSEC)
       NotifyNsecRecord(record);
 #endif
     } else {
@@ skipping 33 matching lines @@
       FOR_EACH_OBSERVER(MDnsListenerImpl, *i->second, AlertNsecRecord());
     }
   }
 }
 
 void MDnsClientImpl::Core::OnConnectionError(int error) {
   // TODO(noamsml): On connection error, recreate connection and flush cache.
 }
 
 void MDnsClientImpl::Core::AlertListeners(
-    MDnsListener::UpdateType update_type,
+    MDnsCache::UpdateType update_type,
     const ListenerKey& key,
     const RecordParsed* record) {
   ListenerMap::iterator listener_map_iterator = listeners_.find(key);
   if (listener_map_iterator == listeners_.end()) return;
 
   FOR_EACH_OBSERVER(MDnsListenerImpl, *listener_map_iterator->second,
-                    AlertDelegate(update_type, record));
+                    HandleRecordUpdate(update_type, record));
 }
 
 void MDnsClientImpl::Core::AddListener(
     MDnsListenerImpl* listener) {
   ListenerKey key(listener->GetName(), listener->GetType());
   std::pair<ListenerMap::iterator, bool> observer_insert_result =
       listeners_.insert(
           make_pair(key, static_cast<ObserverList<MDnsListenerImpl>*>(NULL)));
 
   // If an equivalent key does not exist, actually create the observer list.
@@ skipping 53 matching lines @@
 
 void MDnsClientImpl::Core::DoCleanup() {
   cache_.CleanupRecords(base::Time::Now(), base::Bind(
       &MDnsClientImpl::Core::OnRecordRemoved, base::Unretained(this)));
 
   ScheduleCleanup(cache_.next_expiration());
 }
 
 void MDnsClientImpl::Core::OnRecordRemoved(
     const RecordParsed* record) {
-  AlertListeners(MDnsListener::RECORD_REMOVED,
+  AlertListeners(MDnsCache::RecordRemoved,
                  ListenerKey(record->name(), record->type()), record);
 }
 
 void MDnsClientImpl::Core::QueryCache(
     uint16 rrtype, const std::string& name,
     std::vector<const RecordParsed*>* records) const {
   cache_.FindDnsRecords(rrtype, name, records, base::Time::Now());
 }
 
 MDnsClientImpl::MDnsClientImpl() {
@@ skipping 36 matching lines @@
   return scoped_ptr<MDnsTransaction>(
       new MDnsTransactionImpl(rrtype, name, flags, callback, this));
 }
 
 MDnsListenerImpl::MDnsListenerImpl(
     uint16 rrtype,
     const std::string& name,
     MDnsListener::Delegate* delegate,
     MDnsClientImpl* client)
     : rrtype_(rrtype), name_(name), client_(client), delegate_(delegate),
-      started_(false) {
+      started_(false), active_refresh_(false) {
+}
+
+MDnsListenerImpl::~MDnsListenerImpl() {
+  if (started_) {
+    DCHECK(client_->core());
+    client_->core()->RemoveListener(this);
+  }
 }
 
 bool MDnsListenerImpl::Start() {
   DCHECK(!started_);
 
   started_ = true;
 
   DCHECK(client_->core());
   client_->core()->AddListener(this);
 
   return true;
 }
 
-MDnsListenerImpl::~MDnsListenerImpl() {
+void MDnsListenerImpl::SetActiveRefresh(bool active_refresh) {
+  active_refresh_ = active_refresh;
+
   if (started_) {
-    DCHECK(client_->core());
-    client_->core()->RemoveListener(this);
+    if (!active_refresh_) {
+      next_refresh_.Cancel();
+    } else if (last_update_ != base::Time()) {
+      ScheduleNextRefresh();
+    }
   }
 }
 
 const std::string& MDnsListenerImpl::GetName() const {
   return name_;
 }
 
 uint16 MDnsListenerImpl::GetType() const {
   return rrtype_;
 }
 
-void MDnsListenerImpl::AlertDelegate(MDnsListener::UpdateType update_type,
-                                     const RecordParsed* record) {
+void MDnsListenerImpl::HandleRecordUpdate(MDnsCache::UpdateType update_type,
+                                          const RecordParsed* record) {
   DCHECK(started_);
-  delegate_->OnRecordUpdate(update_type, record);
+
+  if (update_type != MDnsCache::RecordRemoved) {
+    ttl_ = record->ttl();
+    last_update_ = record->time_created();
+
+    ScheduleNextRefresh();
+  }
+
+  if (update_type != MDnsCache::NoChange) {
+    MDnsListener::UpdateType update_external;
+
+    switch (update_type) {
+      case MDnsCache::RecordAdded:
+        update_external = MDnsListener::RECORD_ADDED;
+        break;
+      case MDnsCache::RecordChanged:
+        update_external = MDnsListener::RECORD_CHANGED;
+        break;
+      case MDnsCache::RecordRemoved:
+        update_external = MDnsListener::RECORD_REMOVED;
+        break;
+      case MDnsCache::NoChange:
+      default:
+        NOTREACHED();
+        // Dummy assignment to suppress compiler warning.
+        update_external = MDnsListener::RECORD_CHANGED;
+        break;
+    }
+
+    delegate_->OnRecordUpdate(update_external, record);
+  }
 }
 
 void MDnsListenerImpl::AlertNsecRecord() {
   DCHECK(started_);
   delegate_->OnNsecRecord(name_, rrtype_);
 }
 
+void MDnsListenerImpl::ScheduleNextRefresh() {
+  DCHECK(last_update_ != base::Time());
+
+  if (!active_refresh_)
+    return;
+
+  // A zero TTL is a goodbye packet and should not be refreshed.
+  if (ttl_ == 0) {
+    next_refresh_.Cancel();
+    return;
+  }
+
+  next_refresh_.Reset(base::Bind(&MDnsListenerImpl::DoRefresh,
+                                 AsWeakPtr()));
+
+  // Schedule refreshes at both 85% and 95% of the original TTL. These will both
+  // be canceled and rescheduled if the record's TTL is updated due to a
+  // response being received.
+  base::Time next_refresh1 = last_update_ + base::TimeDelta::FromMilliseconds(
+      static_cast<int>(kMillisecondsPerSecond *
+                       kListenerRefreshRatio1 * ttl_));
+
+  base::Time next_refresh2 = last_update_ + base::TimeDelta::FromMilliseconds(
+      static_cast<int>(kMillisecondsPerSecond *
+                       kListenerRefreshRatio2 * ttl_));
+
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      next_refresh_.callback(),
+      next_refresh1 - base::Time::Now());
+
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      next_refresh_.callback(),
+      next_refresh2 - base::Time::Now());
+}
+
+void MDnsListenerImpl::DoRefresh() {
+  client_->core()->SendQuery(rrtype_, name_);
+}
+
 MDnsTransactionImpl::MDnsTransactionImpl(
     uint16 rrtype,
     const std::string& name,
     int flags,
     const MDnsTransaction::ResultCallback& callback,
     MDnsClientImpl* client)
     : rrtype_(rrtype), name_(name), callback_(callback), client_(client),
       started_(false), flags_(flags) {
   DCHECK((flags_ & MDnsTransaction::FLAG_MASK) == flags_);
   DCHECK(flags_ & MDnsTransaction::QUERY_CACHE ||
@@ skipping 128 matching lines @@
 
 void MDnsTransactionImpl::OnNsecRecord(const std::string& name, unsigned type) {
   TriggerCallback(RESULT_NSEC, NULL);
 }
 
 void MDnsTransactionImpl::OnCachePurged() {
   // TODO(noamsml): Cache purge situations not yet implemented
 }
 
 }  // namespace net