Prefix CommandLine usage with base namespace (Part 7: cloud_print/)

cloud_print/gcp20/prototype/dns_sd_server.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 "cloud_print/gcp20/prototype/dns_sd_server.h"
 
 #include <string.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 80 matching lines @@
 void DnsSdServer::UpdateMetadata(const std::vector<std::string>& metadata) {
   if (!IsOnline())
     return;
 
   metadata_ = metadata;
 
   // TODO(maksymb): If less than 20% of full TTL left before next announcement
   // then send it now.
 
   uint32 current_ttl = GetCurrentTLL();
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoAnnouncement)) {
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kNoAnnouncement)) {
     DnsResponseBuilder builder(current_ttl);
 
     builder.AppendTxt(serv_params_.service_name_, current_ttl, metadata_, true);
     scoped_refptr<net::IOBufferWithSize> buffer(builder.Build());
 
     DCHECK(buffer.get() != NULL);
 
     socket_->SendTo(buffer.get(), buffer.get()->size(), multicast_address_,
                     base::Bind(&DoNothingAfterSendToSocket));
   }
@@ skipping 64 matching lines @@
       break;
     }
   }
 
   scoped_refptr<net::IOBufferWithSize> buffer(builder.Build());
   if (buffer.get() == NULL)
     return;  // No answers.
 
   VLOG(1) << "Current TTL for respond: " << current_ttl;
 
-  bool unicast_respond =
-      CommandLine::ForCurrentProcess()->HasSwitch(switches::kUnicastRespond);
+  bool unicast_respond = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kUnicastRespond);
   socket_->SendTo(buffer.get(), buffer.get()->size(),
                   unicast_respond ? recv_address_ : multicast_address_,
                   base::Bind(&DoNothingAfterSendToSocket));
   VLOG(1) << "Responded to "
       << (unicast_respond ? recv_address_ : multicast_address_).ToString();
 }
 
 void DnsSdServer::ProccessQuery(uint32 current_ttl, const DnsQueryRecord& query,
                                 DnsResponseBuilder* builder) const {
   std::string log;
   bool responded = false;
   switch (query.qtype) {
     // TODO(maksymb): Add IPv6 support.
     case net::dns_protocol::kTypePTR:
       log = "Processing PTR query";
       if (query.qname == serv_params_.service_type_ ||
           query.qname == serv_params_.secondary_service_type_) {
         builder->AppendPtr(query.qname, current_ttl,
                            serv_params_.service_name_, true);
 
-        if (CommandLine::ForCurrentProcess()->HasSwitch(
+        if (base::CommandLine::ForCurrentProcess()->HasSwitch(
                 switches::kExtendedResponce)) {
           builder->AppendSrv(serv_params_.service_name_, current_ttl,
                              kSrvPriority, kSrvWeight, serv_params_.http_port_,
                              serv_params_.service_domain_name_, false);
           builder->AppendA(serv_params_.service_domain_name_, current_ttl,
                            serv_params_.http_ipv4_, false);
           builder->AppendAAAA(serv_params_.service_domain_name_, current_ttl,
                               serv_params_.http_ipv6_, false);
           builder->AppendTxt(serv_params_.service_name_, current_ttl, metadata_,
                              false);
@@ skipping 54 matching lines @@
 
   // TODO(maksymb): Add handler for errors
   DCHECK(rv == net::ERR_IO_PENDING);
 }
 
 void DnsSdServer::OnDatagramReceived() {
   DoLoop(0);
 }
 
 void DnsSdServer::SendAnnouncement(uint32 ttl) {
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoAnnouncement)) {
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kNoAnnouncement)) {
     DnsResponseBuilder builder(ttl);
 
     builder.AppendPtr(serv_params_.service_type_, ttl,
                      serv_params_.service_name_, true);
     builder.AppendPtr(serv_params_.secondary_service_type_, ttl,
                       serv_params_.service_name_, true);
     builder.AppendSrv(serv_params_.service_name_, ttl, kSrvPriority,
                       kSrvWeight, serv_params_.http_port_,
                       serv_params_.service_domain_name_, true);
     builder.AppendA(serv_params_.service_domain_name_, ttl,
@@ skipping 25 matching lines @@
 
 uint32 DnsSdServer::GetCurrentTLL() const {
   uint32 current_ttl = (time_until_live_ - base::Time::Now()).InSeconds();
   if (time_until_live_ < base::Time::Now() || current_ttl == 0) {
     // This should not be reachable. But still we don't need to fail.
     current_ttl = 1;  // Service is still alive.
     LOG(ERROR) << "|current_ttl| was equal to zero.";
   }
   return current_ttl;
 }