Replace all usage of LOG(INFO) in Chromoting host with HOST_LOG to bypass the presubmit check.

remoting/host/remoting_me2me_host.cc

 // Copyright (c) 2012 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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
-#include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "media/base/media.h"
 #include "net/base/network_change_notifier.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/ssl_server_socket.h"
 #include "net/url_request/url_fetcher.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/breakpad.h"
 #include "remoting/base/constants.h"
+#include "remoting/base/logging.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/base/util.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/config_file_watcher.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/desktop_session_connector.h"
 #include "remoting/host/dns_blackhole_checker.h"
@@ skipping 368 matching lines @@
   if (!context_->network_task_runner()->BelongsToCurrentThread()) {
     context_->network_task_runner()->PostTask(FROM_HERE,
         base::Bind(&HostProcess::OnConfigUpdated, this, serialized_config));
     return;
   }
 
   // Filter out duplicates.
   if (serialized_config_ == serialized_config)
     return;
 
-  LOG(INFO) << "Processing new host configuration.";
+  HOST_LOG << "Processing new host configuration.";
 
   serialized_config_ = serialized_config;
   scoped_ptr<JsonHostConfig> config(new JsonHostConfig(base::FilePath()));
   if (!config->SetSerializedData(serialized_config)) {
     LOG(ERROR) << "Invalid configuration.";
     ShutdownHost(kInvalidHostConfigurationExitCode);
     return;
   }
 
   if (!ApplyConfig(config.Pass())) {
@@ skipping 44 matching lines @@
   remoting::RegisterSignalHandler(
       SIGTERM,
       base::Bind(&HostProcess::SigTermHandler, base::Unretained(this)));
 #endif  // defined(OS_POSIX)
 }
 
 #if defined(OS_POSIX)
 void HostProcess::SigTermHandler(int signal_number) {
   DCHECK(signal_number == SIGTERM);
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
-  LOG(INFO) << "Caught SIGTERM: Shutting down...";
+  HOST_LOG << "Caught SIGTERM: Shutting down...";
   ShutdownHost(kSuccessExitCode);
 }
 #endif  // OS_POSIX
 
 void HostProcess::CreateAuthenticatorFactory() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   if (state_ != HOST_STARTED)
     return;
 
@@ skipping 150 matching lines @@
 #endif
 }
 
 // Overridden from HeartbeatSender::Listener
 void HostProcess::OnUnknownHostIdError() {
   LOG(ERROR) << "Host ID not found.";
   ShutdownHost(kInvalidHostIdExitCode);
 }
 
 void HostProcess::OnHeartbeatSuccessful() {
-  LOG(INFO) << "Host ready to receive connections.";
+  HOST_LOG << "Host ready to receive connections.";
 #if defined(OS_POSIX)
   if (signal_parent_) {
     kill(getppid(), SIGUSR1);
     signal_parent_ = false;
   }
 #endif
 }
 
 void HostProcess::OnHostDeleted() {
   LOG(ERROR) << "Host was deleted from the directory.";
@@ skipping 124 matching lines @@
     StartHost();
   } else if (state_ == HOST_STARTED && restart_required) {
     RestartHost();
   }
 }
 
 bool HostProcess::OnHostDomainPolicyUpdate(const std::string& host_domain) {
   // Returns true if the host has to be restarted after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
-  LOG(INFO) << "Policy sets host domain: " << host_domain;
+  HOST_LOG << "Policy sets host domain: " << host_domain;
 
   if (!host_domain.empty() &&
       !EndsWith(host_owner_, std::string("@") + host_domain, false)) {
     ShutdownHost(kInvalidHostDomainExitCode);
   }
   return false;
 }
 
 bool HostProcess::OnUsernamePolicyUpdate(bool curtain_required,
                                          bool host_username_match_required) {
   // Returns false: never restart the host after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   if (host_username_match_required) {
-    LOG(INFO) << "Policy requires host username match.";
+    HOST_LOG << "Policy requires host username match.";
     std::string username = GetUsername();
     bool shutdown = username.empty() ||
         !StartsWithASCII(host_owner_, username + std::string("@"),
                          false);
 
 #if defined(OS_MACOSX)
     // On Mac, we run as root at the login screen, so the username won't match.
     // However, there's no need to enforce the policy at the login screen, as
     // the client will have to reconnect if a login occurs.
     if (shutdown && getuid() == 0) {
       shutdown = false;
     }
 #endif
 
     // Curtain-mode on Windows presents the standard OS login prompt to the user
     // for each connection, removing the need for an explicit user-name matching
     // check.
 #if defined(OS_WIN) && defined(REMOTING_RDP_SESSION)
     if (curtain_required)
       return false;
 #endif  // defined(OS_WIN) && defined(REMOTING_RDP_SESSION)
 
     // Shutdown the host if the username does not match.
     if (shutdown) {
       LOG(ERROR) << "The host username does not match.";
       ShutdownHost(kUsernameMismatchExitCode);
     }
   } else {
-    LOG(INFO) << "Policy does not require host username match.";
+    HOST_LOG << "Policy does not require host username match.";
   }
 
   return false;
 }
 
 bool HostProcess::OnNatPolicyUpdate(bool nat_traversal_enabled) {
   // Returns true if the host has to be restarted after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   if (allow_nat_traversal_ != nat_traversal_enabled) {
     if (nat_traversal_enabled)
-      LOG(INFO) << "Policy enables NAT traversal.";
+      HOST_LOG << "Policy enables NAT traversal.";
     else
-      LOG(INFO) << "Policy disables NAT traversal.";
+      HOST_LOG << "Policy disables NAT traversal.";
     allow_nat_traversal_ = nat_traversal_enabled;
     return true;
   }
   return false;
 }
 
 void HostProcess::OnCurtainPolicyUpdate(bool curtain_required) {
   // Returns true if the host has to be restarted after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
@@ skipping 12 matching lines @@
       LOG(ERROR) << "Running the host in the console login session is yet not "
                     "supported.";
       ShutdownHost(kLoginScreenNotSupportedExitCode);
       return;
     }
   }
 #endif
 
   if (curtain_required_ != curtain_required) {
     if (curtain_required)
-      LOG(INFO) << "Policy requires curtain-mode.";
+      HOST_LOG << "Policy requires curtain-mode.";
     else
-      LOG(INFO) << "Policy does not require curtain-mode.";
+      HOST_LOG << "Policy does not require curtain-mode.";
     curtain_required_ = curtain_required;
     if (host_)
       host_->SetEnableCurtaining(curtain_required_);
   }
 }
 
 bool HostProcess::OnHostTalkGadgetPrefixPolicyUpdate(
     const std::string& talkgadget_prefix) {
   // Returns true if the host has to be restarted after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   if (talkgadget_prefix != talkgadget_prefix_) {
-    LOG(INFO) << "Policy sets talkgadget prefix: " << talkgadget_prefix;
+    HOST_LOG << "Policy sets talkgadget prefix: " << talkgadget_prefix;
     talkgadget_prefix_ = talkgadget_prefix;
     return true;
   }
   return false;
 }
 
 bool HostProcess::OnHostTokenUrlPolicyUpdate(
     const GURL& token_url,
     const GURL& token_validation_url) {
   // Returns true if the host has to be restarted after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   if (token_url_ != token_url ||
       token_validation_url_ != token_validation_url) {
-    LOG(INFO) << "Policy sets third-party token URLs: "
+    HOST_LOG << "Policy sets third-party token URLs: "
               << "TokenUrl: " << token_url << ", "
               << "TokenValidationUrl: " << token_validation_url;
 
     token_url_ = token_url;
     token_validation_url_ = token_validation_url;
     return true;
   }
 
   return false;
 }
 
 bool HostProcess::OnPairingPolicyUpdate(bool allow_pairing) {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   if (allow_pairing_ == allow_pairing)
     return false;
 
   if (allow_pairing)
-    LOG(INFO) << "Policy enables client pairing.";
+    HOST_LOG << "Policy enables client pairing.";
   else
-    LOG(INFO) << "Policy disables client pairing.";
+    HOST_LOG << "Policy disables client pairing.";
   allow_pairing_ = allow_pairing;
   return true;
 }
 
 void HostProcess::StartHost() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
   DCHECK(!host_);
   DCHECK(!signal_strategy_.get());
   DCHECK(state_ == HOST_INITIALIZING || state_ == HOST_STOPPING_TO_RESTART ||
          state_ == HOST_STOPPED) << state_;
@@ skipping 215 matching lines @@
   return exit_code;
 }
 
 }  // namespace remoting
 
 #if !defined(OS_WIN)
 int main(int argc, char** argv) {
   return remoting::HostMain(argc, argv);
 }
 #endif  // !defined(OS_WIN)