Replace ASSERT with DCHECK in modules/

third_party/WebKit/Source/modules/presentation/PresentationConnection.cpp

 // 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 "modules/presentation/PresentationConnection.h"
 
 #include <memory>
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMArrayBufferView.h"
@@ skipping 138 matching lines @@
                                                const String& id,
                                                const KURL& url)
     : ContextClient(frame),
       id_(id),
       url_(url),
       state_(WebPresentationConnectionState::kConnecting),
       binary_type_(kBinaryTypeArrayBuffer),
       proxy_(nullptr) {}
 
 PresentationConnection::~PresentationConnection() {
-  ASSERT(!blob_loader_);
+  DCHECK(!blob_loader_);
 }
 
 void PresentationConnection::BindProxy(
     std::unique_ptr<WebPresentationConnectionProxy> proxy) {
   DCHECK(proxy);
   proxy_ = std::move(proxy);
 }
 
 // static
 PresentationConnection* PresentationConnection::Take(
     ScriptPromiseResolver* resolver,
     const WebPresentationInfo& presentation_info,
     PresentationRequest* request) {
-  ASSERT(resolver);
-  ASSERT(request);
-  ASSERT(resolver->GetExecutionContext()->IsDocument());
+  DCHECK(resolver);
+  DCHECK(request);
+  DCHECK(resolver->GetExecutionContext()->IsDocument());
 
   Document* document = ToDocument(resolver->GetExecutionContext());
   if (!document->GetFrame())
     return nullptr;
 
   PresentationController* controller =
       PresentationController::From(*document->GetFrame());
   if (!controller)
     return nullptr;
 
   return Take(controller, presentation_info, request);
 }
 
 // static
 PresentationConnection* PresentationConnection::Take(
     PresentationController* controller,
     const WebPresentationInfo& presentation_info,
     PresentationRequest* request) {
-  ASSERT(controller);
-  ASSERT(request);
+  DCHECK(controller);
+  DCHECK(request);
 
   PresentationConnection* connection = new PresentationConnection(
       controller->GetFrame(), presentation_info.id, presentation_info.url);
   controller->RegisterConnection(connection);
 
   // Fire onconnectionavailable event asynchronously.
   auto* event = PresentationConnectionAvailableEvent::Create(
       EventTypeNames::connectionavailable, connection);
   TaskRunnerHelper::Get(TaskType::kPresentation, request->GetExecutionContext())
       ->PostTask(BLINK_FROM_HERE,
@@ skipping 81 matching lines @@
     ExceptionState& exception_state) {
   DCHECK(array_buffer_view);
   if (!CanSendMessage(exception_state))
     return;
 
   messages_.push_back(new Message(array_buffer_view.View()->buffer()));
   HandleMessageQueue();
 }
 
 void PresentationConnection::send(Blob* data, ExceptionState& exception_state) {
-  ASSERT(data);
+  DCHECK(data);
   if (!CanSendMessage(exception_state))
     return;
 
   messages_.push_back(new Message(data->GetBlobDataHandle()));
   HandleMessageQueue();
 }
 
 bool PresentationConnection::CanSendMessage(ExceptionState& exception_state) {
   if (state_ != WebPresentationConnectionState::kConnected) {
     ThrowPresentationDisconnectedError(exception_state);
@@ skipping 17 matching lines @@
         messages_.pop_front();
         break;
       case kMessageTypeArrayBuffer:
         client->SendArrayBuffer(
             url_, id_,
             static_cast<const uint8_t*>(message->array_buffer->Data()),
             message->array_buffer->ByteLength(), proxy_.get());
         messages_.pop_front();
         break;
       case kMessageTypeBlob:
-        ASSERT(!blob_loader_);
+        DCHECK(!blob_loader_);
         blob_loader_ = new BlobLoader(message->blob_data_handle, this);
         break;
     }
   }
 }
 
 String PresentationConnection::binaryType() const {
   switch (binary_type_) {
     case kBinaryTypeBlob:
       return "blob";
@@ skipping 172 matching lines @@
 void PresentationConnection::TearDown() {
   // Cancel current Blob loading if any.
   if (blob_loader_) {
     blob_loader_->Cancel();
     blob_loader_.Clear();
   }
   messages_.clear();
 }
 
 }  // namespace blink