Rename enums/functions that collide in chromium style.

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

 // Copyright 2016 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 "core/page/EventSource.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/SerializedScriptValue.h"
@@ skipping 13 matching lines @@
 #include <v8.h>
 
 namespace blink {
 
 namespace {
 
 String dataAsString(ScriptState* scriptState, MessageEvent* event)
 {
     ScriptState::Scope scope(scriptState);
     v8::Isolate* isolate = scriptState->isolate();
-    ASSERT(MessageEvent::DataTypeSerializedScriptValue == event->dataType());
+    ASSERT(MessageEvent::DataTypeSerializedScriptValue == event->getDataType());
     if (!event->dataAsSerializedScriptValue())
         return String();
     MessagePortArray ports = event->ports();
     NonThrowableExceptionState es;
     return toUSVString(isolate, event->dataAsSerializedScriptValue()->deserialize(isolate, &ports), es);
 }
 
 class FakeEventListener : public EventListener {
 public:
     static PassRefPtrWillBeRawPtr<FakeEventListener> create()
@@ skipping 72 matching lines @@
 TEST_F(EventSourceTest, DispatchSimpleMessageEvent)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener("message", listener);
     enqueue("data:hello\n\n");
 
     ASSERT_EQ(1u, listener->events().size());
     ASSERT_EQ("message", listener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event = static_cast<MessageEvent*>(listener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->getDataType());
     EXPECT_EQ("hello", dataAsString(scriptState(), event.get()));
     EXPECT_EQ(String(), event->lastEventId());
 }
 
 TEST_F(EventSourceTest, DispatchMessageEventWithLastEventId)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener("message", listener);
     enqueue("id:99\ndata:hello\n\n");
 
     ASSERT_EQ(1u, listener->events().size());
     ASSERT_EQ("message", listener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event = static_cast<MessageEvent*>(listener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->getDataType());
     EXPECT_EQ("hello", dataAsString(scriptState(), event.get()));
     EXPECT_EQ("99", event->lastEventId());
 }
 
 TEST_F(EventSourceTest, DispatchMessageEventWithCustomEventType)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener("foo", listener);
     enqueue("event:foo\ndata:hello\n\n");
 
     ASSERT_EQ(1u, listener->events().size());
     ASSERT_EQ("foo", listener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event = static_cast<MessageEvent*>(listener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->getDataType());
     EXPECT_EQ("hello", dataAsString(scriptState(), event.get()));
 }
 
 TEST_F(EventSourceTest, RetryTakesEffectEvenWhenNotDispatching)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener("message", listener);
     ASSERT_NE(999u, EventSource::defaultReconnectDelay);
 
     EXPECT_EQ(EventSource::defaultReconnectDelay, source()->reconnectDelayForTest());
     enqueue("retry:999\n");
     EXPECT_EQ(999u, source()->reconnectDelayForTest());
     EXPECT_EQ(0u, listener->events().size());
 }
 
 TEST_F(EventSourceTest, EventTypeShouldBeReset)
 {
     RefPtrWillBeRawPtr<FakeEventListener> fooListener = FakeEventListener::create();
     RefPtrWillBeRawPtr<FakeEventListener> messageListener = FakeEventListener::create();
 
     source()->addEventListener("foo", fooListener);
     source()->addEventListener("message", messageListener);
     enqueue("event:foo\ndata:hello\n\ndata:bye\n\n");
 
     ASSERT_EQ(1u, fooListener->events().size());
     ASSERT_EQ("foo", fooListener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> fooEvent = static_cast<MessageEvent*>(fooListener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, fooEvent->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, fooEvent->getDataType());
     EXPECT_EQ("hello", dataAsString(scriptState(), fooEvent.get()));
 
     ASSERT_EQ(1u, messageListener->events().size());
     ASSERT_EQ("message", messageListener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> messageEvent = static_cast<MessageEvent*>(messageListener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, messageEvent->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, messageEvent->getDataType());
     EXPECT_EQ("bye", dataAsString(scriptState(), messageEvent.get()));
 }
 
 TEST_F(EventSourceTest, DataShouldBeReset)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener("message", listener);
     enqueue("data:hello\n\n\n");
 
     ASSERT_EQ(1u, listener->events().size());
     ASSERT_EQ("message", listener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event = static_cast<MessageEvent*>(listener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->getDataType());
     EXPECT_EQ("hello", dataAsString(scriptState(), event.get()));
 }
 
 TEST_F(EventSourceTest, LastEventIdShouldNotBeReset)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener("message", listener);
     enqueue("id:99\ndata:hello\n\ndata:bye\n\n");
 
     ASSERT_EQ(2u, listener->events().size());
 
     ASSERT_EQ("message", listener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event0 = static_cast<MessageEvent*>(listener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event0->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event0->getDataType());
     EXPECT_EQ("hello", dataAsString(scriptState(), event0.get()));
     EXPECT_EQ("99", event0->lastEventId());
 
     ASSERT_EQ("message", listener->events()[1]->type());
     RefPtrWillBeRawPtr<MessageEvent> event1 = static_cast<MessageEvent*>(listener->events()[1].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event1->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event1->getDataType());
     EXPECT_EQ("bye", dataAsString(scriptState(), event1.get()));
     EXPECT_EQ("99", event1->lastEventId());
 }
 
 TEST_F(EventSourceTest, VariousNewLinesShouldBeAllowed)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener("message", listener);
     enqueueOneByOne("data:hello\r\n\rdata:bye\r\r");
 
     ASSERT_EQ(2u, listener->events().size());
 
     ASSERT_EQ("message", listener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event0 = static_cast<MessageEvent*>(listener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event0->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event0->getDataType());
     EXPECT_EQ("hello", dataAsString(scriptState(), event0.get()));
 
     ASSERT_EQ("message", listener->events()[1]->type());
     RefPtrWillBeRawPtr<MessageEvent> event1 = static_cast<MessageEvent*>(listener->events()[1].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event1->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event1->getDataType());
     EXPECT_EQ("bye", dataAsString(scriptState(), event1.get()));
 }
 
 TEST_F(EventSourceTest, RetryWithEmptyValueShouldRestoreDefaultValue)
 {
     // TODO(yhirano): This is unspecified in the spec. We need to update
     // the implementation or the spec.
     EXPECT_EQ(EventSource::defaultReconnectDelay, source()->reconnectDelayForTest());
     enqueue("retry: 12\n");
     EXPECT_NE(EventSource::defaultReconnectDelay, source()->reconnectDelayForTest());
@@ skipping 38 matching lines @@
 TEST_F(EventSourceTest, UnrecognizedFieldShouldBeIgnored)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener("message", listener);
     enqueue("data:hello\nhoge:fuga\npiyo\n\n");
 
     ASSERT_EQ(1u, listener->events().size());
     ASSERT_EQ("message", listener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event = static_cast<MessageEvent*>(listener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->getDataType());
     EXPECT_EQ("hello", dataAsString(scriptState(), event.get()));
 }
 
 TEST_F(EventSourceTest, CommentShouldBeIgnored)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener("message", listener);
     enqueue("data:hello\n:event:a\n\n");
 
     ASSERT_EQ(1u, listener->events().size());
 
     ASSERT_EQ("message", listener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event0 = static_cast<MessageEvent*>(listener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event0->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event0->getDataType());
     EXPECT_EQ("hello", dataAsString(scriptState(), event0.get()));
 }
 
 TEST_F(EventSourceTest, BOMShouldBeIgnored)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener("message", listener);
     enqueue("\xef\xbb\xbf" "data:hello\n\n");
 
     ASSERT_EQ(1u, listener->events().size());
 
     ASSERT_EQ("message", listener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event0 = static_cast<MessageEvent*>(listener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event0->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event0->getDataType());
     EXPECT_EQ("hello", dataAsString(scriptState(), event0.get()));
 }
 
 TEST_F(EventSourceTest, ColonlessLineShouldBeTreatedAsNameOnlyField)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener("message", listener);
     enqueue("data:hello\nevent:a\nevent\n\n");
 
     ASSERT_EQ(1u, listener->events().size());
 
     ASSERT_EQ("message", listener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event0 = static_cast<MessageEvent*>(listener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event0->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event0->getDataType());
     EXPECT_EQ("hello", dataAsString(scriptState(), event0.get()));
 }
 
 TEST_F(EventSourceTest, AtMostOneLeadingSpaceCanBeSkipped)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener(" type ", listener);
     enqueue("data:  hello  \nevent:  type \n\n");
 
     ASSERT_EQ(1u, listener->events().size());
     ASSERT_EQ(" type ", listener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event = static_cast<MessageEvent*>(listener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->getDataType());
     EXPECT_EQ(" hello  ", dataAsString(scriptState(), event.get()));
 }
 
 TEST_F(EventSourceTest, DataShouldAccumulate)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener("message", listener);
     enqueue("data:hello\ndata: world\ndata\n\n");
 
     ASSERT_EQ(1u, listener->events().size());
     ASSERT_EQ("message", listener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event = static_cast<MessageEvent*>(listener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->getDataType());
     EXPECT_EQ("hello\nworld\n", dataAsString(scriptState(), event.get()));
 }
 
 TEST_F(EventSourceTest, EventShouldNotAccumulate)
 {
     RefPtrWillBeRawPtr<FakeEventListener> aListener = FakeEventListener::create();
     RefPtrWillBeRawPtr<FakeEventListener> bListener = FakeEventListener::create();
 
     source()->addEventListener("a", aListener);
     source()->addEventListener("b", bListener);
     enqueue("data:hello\nevent:a\nevent:b\n\n");
 
     ASSERT_EQ(0u, aListener->events().size());
     ASSERT_EQ(1u, bListener->events().size());
     ASSERT_EQ("b", bListener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event = static_cast<MessageEvent*>(bListener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->getDataType());
     EXPECT_EQ("hello", dataAsString(scriptState(), event.get()));
 }
 
 TEST_F(EventSourceTest, FeedDataOneByOne)
 {
     RefPtrWillBeRawPtr<FakeEventListener> aListener = FakeEventListener::create();
     RefPtrWillBeRawPtr<FakeEventListener> bListener = FakeEventListener::create();
     RefPtrWillBeRawPtr<FakeEventListener> messageListener = FakeEventListener::create();
 
     source()->addEventListener("a", aListener);
     source()->addEventListener("b", bListener);
     source()->addEventListener("message", messageListener);
     enqueueOneByOne("data:hello\r\ndata:world\revent:a\revent:b\nid:4\n\nid:8\ndata:bye\r\n\r");
 
     ASSERT_EQ(0u, aListener->events().size());
 
     ASSERT_EQ(1u, bListener->events().size());
     ASSERT_EQ("b", bListener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> bEvent = static_cast<MessageEvent*>(bListener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, bEvent->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, bEvent->getDataType());
     EXPECT_EQ("hello\nworld", dataAsString(scriptState(), bEvent.get()));
     EXPECT_EQ("4", bEvent->lastEventId());
 
     ASSERT_EQ(1u, messageListener->events().size());
     ASSERT_EQ("message", messageListener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> messageEvent = static_cast<MessageEvent*>(messageListener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, messageEvent->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, messageEvent->getDataType());
     EXPECT_EQ("bye", dataAsString(scriptState(), messageEvent.get()));
     EXPECT_EQ("8", messageEvent->lastEventId());
 }
 
 TEST_F(EventSourceTest, InvalidUTF8Sequence)
 {
     RefPtrWillBeRawPtr<FakeEventListener> listener = FakeEventListener::create();
 
     source()->addEventListener("message", listener);
     enqueue("data:\xffhello\xc2\n\n");
 
     ASSERT_EQ(1u, listener->events().size());
     ASSERT_EQ("message", listener->events()[0]->type());
     RefPtrWillBeRawPtr<MessageEvent> event = static_cast<MessageEvent*>(listener->events()[0].get());
-    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->dataType());
+    ASSERT_EQ(MessageEvent::DataTypeSerializedScriptValue, event->getDataType());
     String expected = String() + replacementCharacter + "hello" + replacementCharacter;
     EXPECT_EQ(expected, dataAsString(scriptState(), event.get()));
 }
 
 } // namespace
 
 } // namespace blink