Move more Mojo bindings helpers out of internal namespace

mojo/public/cpp/bindings/lib/router.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 "mojo/public/cpp/bindings/lib/router.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 42 matching lines @@
         task_runner_->PostTask(FROM_HERE,
                                base::Bind(&Router::RaiseError, router_));
       }
     }
   }
 
   // MessageReceiver implementation:
   bool Accept(Message* message) override {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     accept_was_invoked_ = true;
-    DCHECK(message->has_flag(kMessageIsResponse));
+    DCHECK(message->has_flag(Message::kFlagIsResponse));
 
     bool result = false;
 
     if (router_)
       result = router_->Accept(message);
 
     return result;
   }
 
   // MessageReceiverWithStatus implementation:
@@ skipping 61 matching lines @@
     connector_.AllowWokenUpBySyncWatchOnSameThread();
   connector_.set_incoming_receiver(filters_.GetHead());
   connector_.set_connection_error_handler(
       base::Bind(&Router::OnConnectionError, base::Unretained(this)));
 }
 
 Router::~Router() {}
 
 bool Router::Accept(Message* message) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!message->has_flag(kMessageExpectsResponse));
+  DCHECK(!message->has_flag(Message::kFlagExpectsResponse));
   return connector_.Accept(message);
 }
 
 bool Router::AcceptWithResponder(Message* message, MessageReceiver* responder) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(message->has_flag(kMessageExpectsResponse));
+  DCHECK(message->has_flag(Message::kFlagExpectsResponse));
 
   // Reserve 0 in case we want it to convey special meaning in the future.
   uint64_t request_id = next_request_id_++;
   if (request_id == 0)
     request_id = next_request_id_++;
 
-  bool is_sync = message->has_flag(kMessageIsSync);
+  bool is_sync = message->has_flag(Message::kFlagIsSync);
   message->set_request_id(request_id);
   if (!connector_.Accept(message))
     return false;
 
   if (!is_sync) {
     // We assume ownership of |responder|.
     async_responders_[request_id] = base::WrapUnique(responder);
     return true;
   }
 
@@ skipping 26 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   testing_mode_ = true;
   connector_.set_enforce_errors_from_incoming_receiver(false);
 }
 
 bool Router::HandleIncomingMessage(Message* message) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const bool during_sync_call =
       connector_.during_sync_handle_watcher_callback();
-  if (!message->has_flag(kMessageIsSync) &&
+  if (!message->has_flag(Message::kFlagIsSync) &&
       (during_sync_call || !pending_messages_.empty())) {
     std::unique_ptr<Message> pending_message(new Message);
     message->MoveTo(pending_message.get());
     pending_messages_.push(std::move(pending_message));
 
     if (!pending_task_for_messages_) {
       pending_task_for_messages_ = true;
       connector_.task_runner()->PostTask(
           FROM_HERE, base::Bind(&Router::HandleQueuedMessages,
                                 weak_factory_.GetWeakPtr()));
@@ skipping 27 matching lines @@
   pending_task_for_messages_ = false;
 
   // We may have already seen a connection error from the connector, but
   // haven't notified the user because we want to process all the queued
   // messages first. We should do it now.
   if (connector_.encountered_error() && !encountered_error_)
     OnConnectionError();
 }
 
 bool Router::HandleMessageInternal(Message* message) {
-  if (message->has_flag(kMessageExpectsResponse)) {
+  if (message->has_flag(Message::kFlagExpectsResponse)) {
     if (!incoming_receiver_)
       return false;
 
     MessageReceiverWithStatus* responder = new ResponderThunk(
         weak_factory_.GetWeakPtr(), connector_.task_runner());
     bool ok = incoming_receiver_->AcceptWithResponder(message, responder);
     if (!ok)
       delete responder;
     return ok;
 
-  } else if (message->has_flag(kMessageIsResponse)) {
+  } else if (message->has_flag(Message::kFlagIsResponse)) {
     uint64_t request_id = message->request_id();
 
-    if (message->has_flag(kMessageIsSync)) {
+    if (message->has_flag(Message::kFlagIsSync)) {
       auto it = sync_responses_.find(request_id);
       if (it == sync_responses_.end()) {
         DCHECK(testing_mode_);
         return false;
       }
       it->second->response.reset(new Message());
       message->MoveTo(it->second->response.get());
       *it->second->response_received = true;
       return true;
     }
@@ skipping 36 matching lines @@
 
   encountered_error_ = true;
   if (!error_handler_.is_null())
     error_handler_.Run();
 }
 
 // ----------------------------------------------------------------------------
 
 }  // namespace internal
 }  // namespace mojo