Fix MDnsClient's cache entry cleanup logic.

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 <algorithm>
 #include <queue>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
+#include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/time/time.h"
+#include "base/timer/timer.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
@@ skipping 49 matching lines @@
   multicast_addr_ = GetMDnsIPEndPoint(end_point.GetFamily());
   return DoLoop(0);
 }
 
 int MDnsConnection::SocketHandler::DoLoop(int rv) {
   do {
     if (rv > 0)
       connection_->OnDatagramReceived(&response_, recv_addr_, rv);
 
     rv = socket_->RecvFrom(
-        response_.io_buffer(),
-        response_.io_buffer()->size(),
-        &recv_addr_,
+        response_.io_buffer(), response_.io_buffer()->size(), &recv_addr_,
         base::Bind(&MDnsConnection::SocketHandler::OnDatagramReceived,
                    base::Unretained(this)));
   } while (rv > 0);
 
   if (rv != ERR_IO_PENDING)
     return rv;
 
   return OK;
 }
 
@@ skipping 92 matching lines @@
 
 void MDnsConnection::OnDatagramReceived(
     DnsResponse* response,
     const IPEndPoint& recv_addr,
     int bytes_read) {
   // TODO(noamsml): More sophisticated error handling.
   DCHECK_GT(bytes_read, 0);
   delegate_->HandlePacket(response, bytes_read);
 }
 
-MDnsClientImpl::Core::Core() : connection_(new MDnsConnection(this)) {
+MDnsClientImpl::Core::Core(base::Clock* clock, base::Timer* timer)
+    : clock_(clock),
+      cleanup_timer_(timer),
+      connection_(new MDnsConnection(this)) {
 }
 
 MDnsClientImpl::Core::~Core() {
   STLDeleteValues(&listeners_);
 }
 
 bool MDnsClientImpl::Core::Init(MDnsSocketFactory* socket_factory) {
   return connection_->Init(socket_factory);
 }
 
@@ skipping 25 matching lines @@
   // TODO(noamsml): duplicate query suppression.
   if (!(response->flags() & dns_protocol::kFlagResponse))
     return;  // Message is a query. ignore it.
 
   DnsRecordParser parser = response->Parser();
   unsigned answer_count = response->answer_count() +
       response->additional_answer_count();
 
   for (unsigned i = 0; i < answer_count; i++) {
     offset = parser.GetOffset();
-    scoped_ptr<const RecordParsed> record = RecordParsed::CreateFrom(
-        &parser, base::Time::Now());
+    scoped_ptr<const RecordParsed> record =
+        RecordParsed::CreateFrom(&parser, clock_->Now());
 
     if (!record) {
       DVLOG(1) << "Could not understand an mDNS record.";
 
       if (offset == parser.GetOffset()) {
         DVLOG(1) << "Abandoned parsing the rest of the packet.";
         return;  // The parser did not advance, abort reading the packet.
       } else {
         continue;  // We may be able to extract other records from the packet.
       }
@@ skipping 32 matching lines @@
 }
 
 void MDnsClientImpl::Core::NotifyNsecRecord(const RecordParsed* record) {
   DCHECK_EQ(dns_protocol::kTypeNSEC, record->type());
   const NsecRecordRdata* rdata = record->rdata<NsecRecordRdata>();
   DCHECK(rdata);
 
   // Remove all cached records matching the nonexistent RR types.
   std::vector<const RecordParsed*> records_to_remove;
 
-  cache_.FindDnsRecords(0, record->name(), &records_to_remove,
-                        base::Time::Now());
+  cache_.FindDnsRecords(0, record->name(), &records_to_remove, clock_->Now());
 
   for (std::vector<const RecordParsed*>::iterator i = records_to_remove.begin();
        i != records_to_remove.end(); i++) {
     if ((*i)->type() == dns_protocol::kTypeNSEC)
       continue;
     if (!rdata->GetBit((*i)->type())) {
       scoped_ptr<const RecordParsed> record_removed = cache_.RemoveRecord((*i));
       DCHECK(record_removed);
       OnRecordRemoved(record_removed.get());
     }
@@ skipping 63 matching lines @@
 void MDnsClientImpl::Core::CleanupObserverList(const ListenerKey& key) {
   ListenerMap::iterator found = listeners_.find(key);
   if (found != listeners_.end() && !found->second->might_have_observers()) {
     delete found->second;
     listeners_.erase(found);
   }
 }
 
 void MDnsClientImpl::Core::ScheduleCleanup(base::Time cleanup) {
   // Cleanup is already scheduled, no need to do anything.
-  if (cleanup == scheduled_cleanup_) return;
+  if (cleanup == scheduled_cleanup_) {
+    return;
+  }
   scheduled_cleanup_ = cleanup;
 
   // This cancels the previously scheduled cleanup.
-  cleanup_callback_.Reset(base::Bind(
-      &MDnsClientImpl::Core::DoCleanup, base::Unretained(this)));
+  cleanup_timer_->Stop();
 
   // If |cleanup| is empty, then no cleanup necessary.
   if (cleanup != base::Time()) {
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        cleanup_callback_.callback(),
-        cleanup - base::Time::Now());
+    cleanup_timer_->Start(
+        FROM_HERE, std::max(base::TimeDelta(), cleanup - clock_->Now()),
+        base::Bind(&MDnsClientImpl::Core::DoCleanup, base::Unretained(this)));
   }
 }
 
 void MDnsClientImpl::Core::DoCleanup() {
-  cache_.CleanupRecords(base::Time::Now(), base::Bind(
-      &MDnsClientImpl::Core::OnRecordRemoved, base::Unretained(this)));
+  cache_.CleanupRecords(clock_->Now(),
+                        base::Bind(&MDnsClientImpl::Core::OnRecordRemoved,
+                                   base::Unretained(this)));
 
   ScheduleCleanup(cache_.next_expiration());
 }
 
 void MDnsClientImpl::Core::OnRecordRemoved(
     const RecordParsed* record) {
   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());
+  cache_.FindDnsRecords(rrtype, name, records, clock_->Now());
 }
 
-MDnsClientImpl::MDnsClientImpl() {
+MDnsClientImpl::MDnsClientImpl()
+    : clock_(new base::DefaultClock),
+      cleanup_timer_(new base::Timer(false, false)) {
+}
+
+MDnsClientImpl::MDnsClientImpl(scoped_ptr<base::Clock> clock,
+                               scoped_ptr<base::Timer> timer)
+    : clock_(clock.Pass()), cleanup_timer_(timer.Pass()) {
 }
 
 MDnsClientImpl::~MDnsClientImpl() {
 }
 
 bool MDnsClientImpl::StartListening(MDnsSocketFactory* socket_factory) {
   DCHECK(!core_.get());
-  core_.reset(new Core());
+  core_.reset(new Core(clock_.get(), cleanup_timer_.get()));
   if (!core_->Init(socket_factory)) {
     core_.reset();
     return false;
   }
   return true;
 }
 
 void MDnsClientImpl::StopListening() {
   core_.reset();
 }
 
 bool MDnsClientImpl::IsListening() const {
   return core_.get() != NULL;
 }
 
 scoped_ptr<MDnsListener> MDnsClientImpl::CreateListener(
     uint16 rrtype,
     const std::string& name,
     MDnsListener::Delegate* delegate) {
   return scoped_ptr<net::MDnsListener>(
-      new MDnsListenerImpl(rrtype, name, delegate, this));
+      new MDnsListenerImpl(rrtype, name, clock_.get(), delegate, this));
 }
 
 scoped_ptr<MDnsTransaction> MDnsClientImpl::CreateTransaction(
     uint16 rrtype,
     const std::string& name,
     int flags,
     const MDnsTransaction::ResultCallback& callback) {
   return scoped_ptr<MDnsTransaction>(
       new MDnsTransactionImpl(rrtype, name, flags, callback, this));
 }
 
 MDnsListenerImpl::MDnsListenerImpl(
     uint16 rrtype,
     const std::string& name,
+    base::Clock* clock,
     MDnsListener::Delegate* delegate,
     MDnsClientImpl* client)
-    : rrtype_(rrtype), name_(name), client_(client), delegate_(delegate),
-      started_(false), active_refresh_(false) {
+    : rrtype_(rrtype), name_(name), clock_(clock), client_(client),
+      delegate_(delegate), started_(false), active_refresh_(false) {
 }
 
 MDnsListenerImpl::~MDnsListenerImpl() {
   if (started_) {
     DCHECK(client_->core());
     client_->core()->RemoveListener(this);
   }
 }
 
 bool MDnsListenerImpl::Start() {
@@ skipping 90 matching lines @@
       static_cast<int>(base::Time::kMillisecondsPerSecond *
                        kListenerRefreshRatio1 * ttl_));
 
   base::Time next_refresh2 = last_update_ + base::TimeDelta::FromMilliseconds(
       static_cast<int>(base::Time::kMillisecondsPerSecond *
                        kListenerRefreshRatio2 * ttl_));
 
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       next_refresh_.callback(),
-      next_refresh1 - base::Time::Now());
+      next_refresh1 - clock_->Now());
 
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       next_refresh_.callback(),
-      next_refresh2 - base::Time::Now());
+      next_refresh2 - clock_->Now());
 }
 
 void MDnsListenerImpl::DoRefresh() {
   client_->core()->SendQuery(rrtype_, name_);
 }
 
 MDnsTransactionImpl::MDnsTransactionImpl(
     uint16 rrtype,
     const std::string& name,
     int flags,
@@ skipping 134 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