Rename Blink constants generated from IDL files.

third_party/WebKit/Source/core/page/EventSource.cpp

 /*
  * Copyright (C) 2009, 2012 Ericsson AB. All rights reserved.
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2011, Code Aurora Forum. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 49 matching lines @@
 namespace blink {
 
 const unsigned long long EventSource::defaultReconnectDelay = 3000;
 
 inline EventSource::EventSource(ExecutionContext* context, const KURL& url, const EventSourceInit& eventSourceInit)
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(context)
     , m_url(url)
     , m_currentURL(url)
     , m_withCredentials(eventSourceInit.withCredentials())
-    , m_state(CONNECTING)
+    , m_state(kConnecting)
     , m_connectTimer(this, &EventSource::connectTimerFired)
     , m_reconnectDelay(defaultReconnectDelay)
 {
 }
 
 EventSource* EventSource::create(ExecutionContext* context, const String& url, const EventSourceInit& eventSourceInit, ExceptionState& exceptionState)
 {
     if (url.isEmpty()) {
         exceptionState.throwDOMException(SyntaxError, "Cannot open an EventSource to an empty URL.");
         return nullptr;
@@ skipping 14 matching lines @@
 
     EventSource* source = new EventSource(context, fullURL, eventSourceInit);
 
     source->scheduleInitialConnect();
     source->suspendIfNeeded();
     return source;
 }
 
 EventSource::~EventSource()
 {
-    ASSERT(m_state == CLOSED);
-    ASSERT(!m_loader);
+    DCHECK_EQ(kClosed, m_state);
+    DCHECK(!m_loader);
 }
 
 void EventSource::scheduleInitialConnect()
 {
-    ASSERT(m_state == CONNECTING);
-    ASSERT(!m_loader);
+    DCHECK_EQ(kConnecting, m_state);
+    DCHECK(!m_loader);
 
     m_connectTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void EventSource::connect()
 {
-    ASSERT(m_state == CONNECTING);
-    ASSERT(!m_loader);
-    ASSERT(getExecutionContext());
+    DCHECK_EQ(kConnecting, m_state);
+    DCHECK(!m_loader);
+    DCHECK(getExecutionContext());
 
     ExecutionContext& executionContext = *this->getExecutionContext();
     ResourceRequest request(m_currentURL);
     request.setHTTPMethod(HTTPNames::GET);
     request.setHTTPHeaderField(HTTPNames::Accept, "text/event-stream");
     request.setHTTPHeaderField(HTTPNames::Cache_Control, "no-cache");
     request.setRequestContext(WebURLRequest::RequestContextEventSource);
     request.setExternalRequestStateFromRequestorAddressSpace(executionContext.securityContext().addressSpace());
     if (m_parser && !m_parser->lastEventId().isEmpty()) {
         // HTTP headers are Latin-1 byte strings, but the Last-Event-ID header is encoded as UTF-8.
@@ skipping 20 matching lines @@
     m_loader = ThreadableLoader::create(executionContext, this, options, resourceLoaderOptions);
     m_loader->start(request);
 }
 
 void EventSource::networkRequestEnded()
 {
     InspectorInstrumentation::didFinishEventSourceRequest(getExecutionContext(), this);
 
     m_loader = nullptr;
 
-    if (m_state != CLOSED)
+    if (m_state != kClosed)
         scheduleReconnect();
 }
 
 void EventSource::scheduleReconnect()
 {
-    m_state = CONNECTING;
+    m_state = kConnecting;
     m_connectTimer.startOneShot(m_reconnectDelay / 1000.0, BLINK_FROM_HERE);
     dispatchEvent(Event::create(EventTypeNames::error));
 }
 
 void EventSource::connectTimerFired(Timer<EventSource>*)
 {
     connect();
 }
 
 String EventSource::url() const
 {
     return m_url.getString();
 }
 
 bool EventSource::withCredentials() const
 {
     return m_withCredentials;
 }
 
 EventSource::State EventSource::readyState() const
 {
     return m_state;
 }
 
 void EventSource::close()
 {
-    if (m_state == CLOSED) {
-        ASSERT(!m_loader);
+    if (m_state == kClosed) {
+        DCHECK(!m_loader);
         return;
     }
     if (m_parser)
         m_parser->stop();
 
     // Stop trying to reconnect if EventSource was explicitly closed or if ActiveDOMObject::stop() was called.
     if (m_connectTimer.isActive()) {
         m_connectTimer.stop();
     }
 
     if (m_loader) {
         m_loader->cancel();
         m_loader = nullptr;
     }
 
-    m_state = CLOSED;
+    m_state = kClosed;
 }
 
 const AtomicString& EventSource::interfaceName() const
 {
     return EventTargetNames::EventSource;
 }
 
 ExecutionContext* EventSource::getExecutionContext() const
 {
     return ActiveDOMObject::getExecutionContext();
 }
 
 void EventSource::didReceiveResponse(unsigned long, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
 {
     ASSERT_UNUSED(handle, !handle);
-    ASSERT(m_state == CONNECTING);
-    ASSERT(m_loader);
+    DCHECK_EQ(kConnecting, m_state);
+    DCHECK(m_loader);
 
     m_currentURL = response.url();
     m_eventStreamOrigin = SecurityOrigin::create(response.url())->toString();
     int statusCode = response.httpStatusCode();
     bool mimeTypeIsValid = response.mimeType() == "text/event-stream";
     bool responseIsValid = statusCode == 200 && mimeTypeIsValid;
     if (responseIsValid) {
         const String& charset = response.textEncodingName();
         // If we have a charset, the only allowed value is UTF-8 (case-insensitive).
         responseIsValid = charset.isEmpty() || equalIgnoringCase(charset, "UTF-8");
@@ skipping 11 matching lines @@
             StringBuilder message;
             message.append("EventSource's response has a MIME type (\"");
             message.append(response.mimeType());
             message.append("\") that is not \"text/event-stream\". Aborting the connection.");
             // FIXME: We are missing the source line.
             getExecutionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message.toString()));
         }
     }
 
     if (responseIsValid) {
-        m_state = OPEN;
+        m_state = kOpen;
         AtomicString lastEventId;
         if (m_parser) {
             // The new parser takes over the event ID.
             lastEventId = m_parser->lastEventId();
         }
         m_parser = new EventSourceParser(lastEventId, this);
         dispatchEvent(Event::create(EventTypeNames::open));
     } else {
         m_loader->cancel();
         dispatchEvent(Event::create(EventTypeNames::error));
     }
 }
 
 void EventSource::didReceiveData(const char* data, unsigned length)
 {
-    ASSERT(m_state == OPEN);
-    ASSERT(m_loader);
-    ASSERT(m_parser);
+    DCHECK_EQ(kOpen, m_state);
+    DCHECK(m_loader);
+    DCHECK(m_parser);
 
     m_parser->addBytes(data, length);
 }
 
 void EventSource::didFinishLoading(unsigned long, double)
 {
-    ASSERT(m_state == OPEN);
-    ASSERT(m_loader);
+    DCHECK_EQ(kOpen, m_state);
+    DCHECK(m_loader);
 
     networkRequestEnded();
 }
 
 void EventSource::didFail(const ResourceError& error)
 {
-    ASSERT(m_state != CLOSED);
-    ASSERT(m_loader);
+    DCHECK_NE(kClosed, m_state);
+    DCHECK(m_loader);
 
     if (error.isCancellation())
-        m_state = CLOSED;
+        m_state = kClosed;
     networkRequestEnded();
 }
 
 void EventSource::didFailAccessControlCheck(const ResourceError& error)
 {
-    ASSERT(m_loader);
+    DCHECK(m_loader);
 
     String message = "EventSource cannot load " + error.failingURL() + ". " + error.localizedDescription();
     getExecutionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
 
     abortConnectionAttempt();
 }
 
 void EventSource::didFailRedirectCheck()
 {
-    ASSERT(m_loader);
+    DCHECK(m_loader);
 
     abortConnectionAttempt();
 }
 
 void EventSource::onMessageEvent(const AtomicString& eventType, const String& data, const AtomicString& lastEventId)
 {
     MessageEvent* e = MessageEvent::create();
     e->initMessageEvent(eventType, false, false, SerializedScriptValue::serialize(data), m_eventStreamOrigin, lastEventId, 0, nullptr);
 
     InspectorInstrumentation::willDispatchEventSourceEvent(getExecutionContext(), this, eventType, lastEventId, data);
     dispatchEvent(e);
 }
 
 void EventSource::onReconnectionTimeSet(unsigned long long reconnectionTime)
 {
     m_reconnectDelay = reconnectionTime;
 }
 
 void EventSource::abortConnectionAttempt()
 {
-    ASSERT(m_state == CONNECTING);
+    DCHECK_EQ(kConnecting, m_state);
 
     m_loader = nullptr;
-    m_state = CLOSED;
+    m_state = kClosed;
     networkRequestEnded();
 
     dispatchEvent(Event::create(EventTypeNames::error));
 }
 
 void EventSource::stop()
 {
     close();
 }
 
 bool EventSource::hasPendingActivity() const
 {
-    return m_state != CLOSED;
+    return m_state != kClosed;
 }
 
 DEFINE_TRACE(EventSource)
 {
     visitor->trace(m_parser);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
     EventSourceParser::Client::trace(visitor);
 }
 
 } // namespace blink