Move //mojo/services/network/public/interfaces to //mojo/services/network/interfaces.

mojo/services/network/udp_socket_wrapper.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 "network/public/cpp/udp_socket_wrapper.h"
+#include "mojo/services/network/udp_socket_wrapper.h"
 
-#include <assert.h>
-
-#include "third_party/mojo/src/mojo/public/cpp/environment/logging.h"
+#include "base/logging.h"
 
 namespace mojo {
 namespace {
 
 const uint32_t kDefaultReceiveQueueSlots = 32;
 
 }  // namespace
 
 UDPSocketWrapper::NegotiateCallbackHandler::NegotiateCallbackHandler(
     UDPSocketWrapper* delegate)
@@ skipping 125 matching lines @@
                               const ErrorCallback& callback) {
   if (current_pending_sends_ >= max_pending_sends_) {
     SendRequest* request = new SendRequest();
     request->dest_addr = dest_addr.Pass();
     request->data = data.Pass();
     request->callback = callback;
     send_requests_.push(request);
     return;
   }
 
-  MOJO_DCHECK(send_requests_.empty());
+  DCHECK(send_requests_.empty());
   current_pending_sends_++;
   socket_->SendTo(dest_addr.Pass(), data.Pass(),
                   ErrorCallback(static_cast<ErrorCallback::Runnable*>(
                       new SendCallbackHandler(this, callback))));
 }
 
 void UDPSocketWrapper::OnReceived(NetworkErrorPtr result,
                                   NetAddressPtr src_addr,
                                   Array<uint8_t> data) {
   if (!receive_requests_.empty()) {
     // The cache should be empty if there are user requests waiting for data.
-    MOJO_DCHECK(receive_queue_.empty());
+    DCHECK(receive_queue_.empty());
 
     socket_->ReceiveMore(1);
 
     ReceiveCallback callback = receive_requests_.front();
     receive_requests_.pop();
 
     callback.Run(result.Pass(), src_addr.Pass(), data.Pass());
     return;
   }
 
-  MOJO_DCHECK(receive_queue_.size() < max_receive_queue_size_);
+  DCHECK_LT(receive_queue_.size(), max_receive_queue_size_);
   ReceivedData* received_data = new ReceivedData();
   received_data->result = result.Pass();
   received_data->src_addr = src_addr.Pass();
   received_data->data = data.Pass();
   receive_queue_.push(received_data);
 }
 
 void UDPSocketWrapper::Initialize(uint32_t requested_max_pending_sends) {
   socket_->NegotiateMaxPendingSendRequests(
       requested_max_pending_sends,
       Callback<void(uint32_t)>(
           static_cast< Callback<void(uint32_t)>::Runnable*>(
               new NegotiateCallbackHandler(this))));
 }
 
 void UDPSocketWrapper::OnNegotiateMaxPendingSendRequestsCompleted(
     uint32_t actual_size) {
-  MOJO_DCHECK(max_pending_sends_ == 1);
+  DCHECK_EQ(max_pending_sends_, 1u);
 
   if (actual_size == 0) {
-    assert(false);
+    NOTREACHED();
     return;
   }
 
   max_pending_sends_ = actual_size;
 
   while (ProcessNextSendRequest());
 }
 
 void UDPSocketWrapper::OnSendToCompleted(
     NetworkErrorPtr result,
@@ skipping 23 matching lines @@
   return true;
 }
 
 void UDPSocketWrapper::StartReceivingData(
     InterfaceRequest<UDPSocketReceiver> request) {
   binding_.Bind(request.Pass());
   socket_->ReceiveMore(max_receive_queue_size_);
 }
 
 }  // namespace mojo