Cleanup namespace usage in Source/core/modules/[mediasource/* to websockets/*]

Source/modules/mediastream/RTCPeerConnection.h

 /*
  * Copyright (C) 2012 Google Inc. 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 39 matching lines @@
 class RTCDataChannel;
 class RTCErrorCallback;
 class RTCOfferOptions;
 class RTCSessionDescription;
 class RTCSessionDescriptionCallback;
 class RTCStatsCallback;
 class VoidCallback;
 
 class RTCPeerConnection FINAL
     : public RefCountedGarbageCollectedWillBeGarbageCollectedFinalized<RTCPeerConnection>
-    , public blink::WebRTCPeerConnectionHandlerClient
+    , public WebRTCPeerConnectionHandlerClient
     , public EventTargetWithInlineData
     , public ActiveDOMObject {
     DEFINE_EVENT_TARGET_REFCOUNTING_WILL_BE_REMOVED(RefCountedGarbageCollectedWillBeGarbageCollectedFinalized<RTCPeerConnection>);
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(RTCPeerConnection);
 public:
     static RTCPeerConnection* create(ExecutionContext*, const Dictionary&, const Dictionary&, ExceptionState&);
     virtual ~RTCPeerConnection();
 
     void createOffer(PassOwnPtr<RTCSessionDescriptionCallback>, PassOwnPtr<RTCErrorCallback>, const Dictionary&, ExceptionState&);
 
@@ skipping 41 matching lines @@
     bool shouldFireGetStatsCallback() { return !m_stopped; }
 
     DEFINE_ATTRIBUTE_EVENT_LISTENER(negotiationneeded);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(icecandidate);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(signalingstatechange);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(addstream);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(removestream);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(iceconnectionstatechange);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(datachannel);
 
-    // blink::WebRTCPeerConnectionHandlerClient
+    // WebRTCPeerConnectionHandlerClient
     virtual void negotiationNeeded() OVERRIDE;
-    virtual void didGenerateICECandidate(const blink::WebRTCICECandidate&) OVERRIDE;
+    virtual void didGenerateICECandidate(const WebRTCICECandidate&) OVERRIDE;
     virtual void didChangeSignalingState(SignalingState) OVERRIDE;
     virtual void didChangeICEGatheringState(ICEGatheringState) OVERRIDE;
     virtual void didChangeICEConnectionState(ICEConnectionState) OVERRIDE;
-    virtual void didAddRemoteStream(const blink::WebMediaStream&) OVERRIDE;
-    virtual void didRemoveRemoteStream(const blink::WebMediaStream&) OVERRIDE;
-    virtual void didAddRemoteDataChannel(blink::WebRTCDataChannelHandler*) OVERRIDE;
+    virtual void didAddRemoteStream(const WebMediaStream&) OVERRIDE;
+    virtual void didRemoveRemoteStream(const WebMediaStream&) OVERRIDE;
+    virtual void didAddRemoteDataChannel(WebRTCDataChannelHandler*) OVERRIDE;
     virtual void releasePeerConnectionHandler() OVERRIDE;
 
     // EventTarget
     virtual const AtomicString& interfaceName() const OVERRIDE;
     virtual ExecutionContext* executionContext() const OVERRIDE;
 
     // ActiveDOMObject
     virtual void suspend() OVERRIDE;
     virtual void resume() OVERRIDE;
     virtual void stop() OVERRIDE;
     // We keep the this object alive until either stopped or closed.
     virtual bool hasPendingActivity() const OVERRIDE
     {
         return !m_closed && !m_stopped;
     }
 
     virtual void trace(Visitor*) OVERRIDE;
 
 private:
-    RTCPeerConnection(ExecutionContext*, PassRefPtr<RTCConfiguration>, blink::WebMediaConstraints, ExceptionState&);
+    RTCPeerConnection(ExecutionContext*, PassRefPtr<RTCConfiguration>, WebMediaConstraints, ExceptionState&);
 
     static PassRefPtr<RTCConfiguration> parseConfiguration(const Dictionary&, ExceptionState&);
     static PassRefPtr<RTCOfferOptions> parseOfferOptions(const Dictionary&, ExceptionState&);
 
     void scheduleDispatchEvent(PassRefPtrWillBeRawPtr<Event>);
     void dispatchScheduledEvent();
     bool hasLocalStreamWithTrackId(const String& trackId);
 
-    void changeSignalingState(blink::WebRTCPeerConnectionHandlerClient::SignalingState);
-    void changeIceGatheringState(blink::WebRTCPeerConnectionHandlerClient::ICEGatheringState);
-    void changeIceConnectionState(blink::WebRTCPeerConnectionHandlerClient::ICEConnectionState);
+    void changeSignalingState(WebRTCPeerConnectionHandlerClient::SignalingState);
+    void changeIceGatheringState(WebRTCPeerConnectionHandlerClient::ICEGatheringState);
+    void changeIceConnectionState(WebRTCPeerConnectionHandlerClient::ICEConnectionState);
 
     SignalingState m_signalingState;
     ICEGatheringState m_iceGatheringState;
     ICEConnectionState m_iceConnectionState;
 
     MediaStreamVector m_localStreams;
     MediaStreamVector m_remoteStreams;
 
     HeapVector<Member<RTCDataChannel> > m_dataChannels;
 
-    OwnPtr<blink::WebRTCPeerConnectionHandler> m_peerHandler;
+    OwnPtr<WebRTCPeerConnectionHandler> m_peerHandler;
 
     AsyncMethodRunner<RTCPeerConnection> m_dispatchScheduledEventRunner;
     WillBeHeapVector<RefPtrWillBeMember<Event> > m_scheduledEvents;
 
     bool m_stopped;
     bool m_closed;
 };
 
 } // namespace blink
 
 #endif // RTCPeerConnection_h