Move more Mojo bindings helpers out of internal namespace

mojo/public/cpp/bindings/lib/interface_endpoint_client.cc

 // Copyright 2015 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/interface_endpoint_client.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 52 matching lines @@
             FROM_HERE,
             base::Bind(&InterfaceEndpointClient::RaiseError, endpoint_client_));
       }
     }
   }
 
   // MessageReceiver implementation:
   bool Accept(Message* message) override {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     accept_was_invoked_ = true;
-    DCHECK(message->has_flag(internal::kMessageIsResponse));
+    DCHECK(message->has_flag(Message::kFlagIsResponse));
 
     bool result = false;
 
     if (endpoint_client_)
       result = endpoint_client_->Accept(message);
 
     return result;
   }
 
   // MessageReceiverWithStatus implementation:
@@ skipping 104 matching lines @@
 
 void InterfaceEndpointClient::RaiseError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   handle_.group_controller()->RaiseError();
 }
 
 bool InterfaceEndpointClient::Accept(Message* message) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(controller_);
-  DCHECK(!message->has_flag(internal::kMessageExpectsResponse));
+  DCHECK(!message->has_flag(Message::kFlagExpectsResponse));
 
   if (encountered_error_)
     return false;
 
   return controller_->SendMessage(message);
 }
 
 bool InterfaceEndpointClient::AcceptWithResponder(Message* message,
                                                   MessageReceiver* responder) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(controller_);
-  DCHECK(message->has_flag(internal::kMessageExpectsResponse));
+  DCHECK(message->has_flag(Message::kFlagExpectsResponse));
 
   if (encountered_error_)
     return false;
 
   // 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_++;
 
   message->set_request_id(request_id);
 
-  bool is_sync = message->has_flag(internal::kMessageIsSync);
+  bool is_sync = message->has_flag(Message::kFlagIsSync);
   if (!controller_->SendMessage(message))
     return false;
 
   if (!is_sync) {
     // We assume ownership of |responder|.
     async_responders_[request_id] = base::WrapUnique(responder);
     return true;
   }
 
   SyncCallRestrictions::AssertSyncCallAllowed();
@@ skipping 34 matching lines @@
   if (encountered_error_)
     return;
   encountered_error_ = true;
   if (!error_handler_.is_null())
     error_handler_.Run();
 }
 
 bool InterfaceEndpointClient::HandleValidatedMessage(Message* message) {
   DCHECK_EQ(handle_.id(), message->interface_id());
 
-  if (message->has_flag(internal::kMessageExpectsResponse)) {
+  if (message->has_flag(Message::kFlagExpectsResponse)) {
     if (!incoming_receiver_)
       return false;
 
     MessageReceiverWithStatus* responder =
         new ResponderThunk(weak_ptr_factory_.GetWeakPtr(), task_runner_);
     bool ok = incoming_receiver_->AcceptWithResponder(message, responder);
     if (!ok)
       delete responder;
     return ok;
-  } else if (message->has_flag(internal::kMessageIsResponse)) {
+  } else if (message->has_flag(Message::kFlagIsResponse)) {
     uint64_t request_id = message->request_id();
 
-    if (message->has_flag(internal::kMessageIsSync)) {
+    if (message->has_flag(Message::kFlagIsSync)) {
       auto it = sync_responses_.find(request_id);
       if (it == sync_responses_.end())
         return false;
       it->second->response.reset(new Message());
       message->MoveTo(it->second->response.get());
       *it->second->response_received = true;
       return true;
     }
 
     auto it = async_responders_.find(request_id);
     if (it == async_responders_.end())
       return false;
     std::unique_ptr<MessageReceiver> responder = std::move(it->second);
     async_responders_.erase(it);
     return responder->Accept(message);
   } else {
     if (!incoming_receiver_)
       return false;
 
     return incoming_receiver_->Accept(message);
   }
 }
 
 }  // namespace mojo