For C++ readability review.

remoting/host/it2me/it2me_native_messaging_host.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 "remoting/host/it2me/it2me_native_messaging_host.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 36 matching lines @@
       factory_(factory.Pass()),
       weak_factory_(this) {
   weak_ptr_ = weak_factory_.GetWeakPtr();
 
   // Initialize the host context to manage the threads for the it2me host.
   // The native messaging host, rather than the It2MeHost object, owns and
   // maintains the lifetime of the host context.
 
   host_context_.reset(ChromotingHostContext::Create(task_runner).release());
 
-  ServiceUrls* service_urls = ServiceUrls::GetInstance();
-  bool xmpp_server_valid =
+  const ServiceUrls* const service_urls = ServiceUrls::GetInstance();

[nadav, 2014/02/19 16:21:53]

That's probably too many consts.
Unless you really need all of them to compile, or the code around you does it
too, in nested pointer situation we typically only put the first "const":
https://engdoc.corp.google.com/eng/doc/devguide/cpp/styleguide.shtml?cl=head#...

[weitao, 2014/02/19 17:52:18]

Done.

+  const bool xmpp_server_valid =
       net::ParseHostAndPort(service_urls->xmpp_server_address(),
                             &xmpp_server_config_.host,
                             &xmpp_server_config_.port);
   DCHECK(xmpp_server_valid);
 
   xmpp_server_config_.use_tls = service_urls->xmpp_server_use_tls();
   directory_bot_jid_ = service_urls->directory_bot_jid();
 }
 
 It2MeNativeMessagingHost::~It2MeNativeMessagingHost() {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
   if (it2me_host_.get()) {
     it2me_host_->Disconnect();
     it2me_host_ = NULL;
   }
 }
 
-void It2MeNativeMessagingHost::Start(const base::Closure& quit_closure) {
+void It2MeNativeMessagingHost::Start(const base::Closure& quit_closure) const {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
   channel_->Start(
       base::Bind(&It2MeNativeMessagingHost::ProcessMessage, weak_ptr_),
       quit_closure);
 }
 
 void It2MeNativeMessagingHost::ProcessMessage(
     scoped_ptr<base::DictionaryValue> message) {
   DCHECK(task_runner()->BelongsToCurrentThread());
@@ skipping 20 matching lines @@
     ProcessConnect(*message, response.Pass());
   } else if (type == "disconnect") {
     ProcessDisconnect(*message, response.Pass());
   } else {
     SendErrorAndExit(response.Pass(), "Unsupported request type: " + type);
   }
 }
 
 void It2MeNativeMessagingHost::ProcessHello(
     const base::DictionaryValue& message,
-    scoped_ptr<base::DictionaryValue> response) {
+    scoped_ptr<base::DictionaryValue> response) const {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
   response->SetString("version", STRINGIZE(VERSION));
 
   // This list will be populated when new features are added.
   scoped_ptr<base::ListValue> supported_features_list(new base::ListValue());
   response->Set("supportedFeatures", supported_features_list.release());
 
   channel_->SendMessage(response.Pass());
 }
@@ skipping 79 matching lines @@
 
   if (it2me_host_.get()) {
     it2me_host_->Disconnect();
     it2me_host_ = NULL;
   }
   channel_->SendMessage(response.Pass());
 }
 
 void It2MeNativeMessagingHost::SendErrorAndExit(
     scoped_ptr<base::DictionaryValue> response,
-    const std::string& description) {
+    const std::string& description) const {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
   LOG(ERROR) << description;
 
   response->SetString("type", "error");
   response->SetString("description", description);
   channel_->SendMessage(response.Pass());
 
   // Trigger a host shutdown by sending a NULL message.
   channel_->SendMessage(scoped_ptr<base::DictionaryValue>());
@@ skipping 53 matching lines @@
 }
 
 // Stores the client user's name for the web-app to query.
 void It2MeNativeMessagingHost::OnClientAuthenticated(
     const std::string& client_username) {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
   client_username_ = client_username;
 }
 
-scoped_refptr<AutoThreadTaskRunner> It2MeNativeMessagingHost::task_runner() {
+scoped_refptr<AutoThreadTaskRunner>
+It2MeNativeMessagingHost::task_runner() const {
   return host_context_->ui_task_runner();
 }
 
 /* static */
 std::string It2MeNativeMessagingHost::HostStateToString(
     It2MeHostState host_state) {
   return ValueToName(kIt2MeHostStates, host_state);
 }
 
 }  // namespace remoting
+