Remove the (broken and unneeded) 'force_update' option from ServiceWatcher::DiscoverNewDevices.

chrome/browser/local_discovery/service_discovery_client_impl.cc

 // Copyright 2014 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/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
@@ skipping 60 matching lines @@
   listener_ = mdns_client_->CreateListener(
       net::dns_protocol::kTypePTR, service_type_, this);
   started_ = listener_->Start();
   if (started_)
     ReadCachedServices();
 }
 
 ServiceWatcherImpl::~ServiceWatcherImpl() {
 }
 
-void ServiceWatcherImpl::DiscoverNewServices(bool force_update) {
+void ServiceWatcherImpl::DiscoverNewServices() {
   DCHECK(started_);
-  if (force_update)
-    services_.clear();
-  SendQuery(kInitialRequeryTimeSeconds, force_update);
+  SendQuery(kInitialRequeryTimeSeconds);
 }
 
 void ServiceWatcherImpl::SetActivelyRefreshServices(
     bool actively_refresh_services) {
   DCHECK(started_);
   actively_refresh_services_ = actively_refresh_services;
 
   for (auto& it : services_)
     it.second->SetActiveRefresh(actively_refresh_services);
 }
 
 void ServiceWatcherImpl::ReadCachedServices() {
   DCHECK(started_);
-  CreateTransaction(false /*network*/, true /*cache*/, false /*force refresh*/,
-                    &transaction_cache_);
+  CreateTransaction(false /*network*/, true /*cache*/, &transaction_cache_);
 }
 
 bool ServiceWatcherImpl::CreateTransaction(
     bool network,
     bool cache,
-    bool force_refresh,
     std::unique_ptr<net::MDnsTransaction>* transaction) {
   int transaction_flags = 0;
   if (network)
     transaction_flags |= net::MDnsTransaction::QUERY_NETWORK;
 
   if (cache)
     transaction_flags |= net::MDnsTransaction::QUERY_CACHE;
 
-  // TODO(noamsml): Add flag for force_refresh when supported.
   if (transaction_flags) {
     *transaction = mdns_client_->CreateTransaction(
         net::dns_protocol::kTypePTR, service_type_, transaction_flags,
         base::Bind(&ServiceWatcherImpl::OnTransactionResponse,
                    AsWeakPtr(), transaction));
     return (*transaction)->Start();
   }
 
   return true;
 }
@@ skipping 185 matching lines @@
                                       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::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::BindOnce(&ServiceWatcherImpl::SendQuery, AsWeakPtr(),
-                       timeout_seconds * 2 /*next_timeout_seconds*/,
-                       false /*force_update*/),
+                       timeout_seconds * 2 /*next_timeout_seconds*/),
         base::TimeDelta::FromSeconds(timeout_seconds));
   }
 }
 
-void ServiceWatcherImpl::SendQuery(int next_timeout_seconds,
-                                   bool force_update) {
-  CreateTransaction(true /*network*/, false /*cache*/, force_update,
-                    &transaction_network_);
+void ServiceWatcherImpl::SendQuery(int next_timeout_seconds) {
+  CreateTransaction(true /*network*/, false /*cache*/, &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) {
@@ skipping 215 matching lines @@
 }
 
 void LocalDomainResolverImpl::SendResolvedAddresses() {
   transaction_a_.reset();
   transaction_aaaa_.reset();
   timeout_callback_.Cancel();
   callback_.Run(IsSuccess(), address_ipv4_, address_ipv6_);
 }
 
 }  // namespace local_discovery