Cleanup HTMLMediaElement to use anonymous namespace.

third_party/WebKit/Source/core/html/HTMLMediaElement.cpp

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 69 matching lines @@
 #include "public/platform/Platform.h"
 #include "public/platform/WebAudioSourceProvider.h"
 #include "public/platform/WebContentDecryptionModule.h"
 #include "public/platform/WebInbandTextTrack.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/MainThread.h"
 #include "wtf/MathExtras.h"
 #include "wtf/text/CString.h"
 #include <limits>
 
+#ifndef LOG_MEDIA_EVENTS
+// Default to not logging events because so many are generated they can overwhelm the rest of
+// the logging.
+#define LOG_MEDIA_EVENTS 0
+#endif
+
+#ifndef LOG_CACHED_TIME_WARNINGS
+// Default to not logging warnings about excessive drift in the cached media time because it adds a
+// fair amount of overhead and logging.
+#define LOG_CACHED_TIME_WARNINGS 0
+#endif
 
 namespace blink {
 
+using namespace HTMLNames;
+
+using WeakMediaElementSet = WillBeHeapHashSet<RawPtrWillBeWeakMember<HTMLMediaElement>>;
+using DocumentElementSetMap = WillBeHeapHashMap<RawPtrWillBeWeakMember<Document>, WeakMediaElementSet>;
+
+namespace {
+
+// URL protocol used to signal that the media source API is being used.
+const char mediaSourceBlobProtocol[] = "blob";
+
 #if !LOG_DISABLED
-static String urlForLoggingMedia(const KURL& url)
+String urlForLoggingMedia(const KURL& url)
 {
     static const unsigned maximumURLLengthForLogging = 128;
 
     if (url.string().length() < maximumURLLengthForLogging)
         return url.string();
     return url.string().substring(0, maximumURLLengthForLogging) + "...";
 }
 
-static const char* boolString(bool val)
+const char* boolString(bool val)
 {
     return val ? "true" : "false";
 }
 #endif
 
-#ifndef LOG_MEDIA_EVENTS
-// Default to not logging events because so many are generated they can overwhelm the rest of
-// the logging.
-#define LOG_MEDIA_EVENTS 0
-#endif
-
-#ifndef LOG_CACHED_TIME_WARNINGS
-// Default to not logging warnings about excessive drift in the cached media time because it adds a
-// fair amount of overhead and logging.
-#define LOG_CACHED_TIME_WARNINGS 0
-#endif
-
-// URL protocol used to signal that the media source API is being used.
-static const char mediaSourceBlobProtocol[] = "blob";
-
-using namespace HTMLNames;
-
-typedef WillBeHeapHashSet<RawPtrWillBeWeakMember<HTMLMediaElement>> WeakMediaElementSet;
-typedef WillBeHeapHashMap<RawPtrWillBeWeakMember<Document>, WeakMediaElementSet> DocumentElementSetMap;
-static DocumentElementSetMap& documentToElementSetMap()
+DocumentElementSetMap& documentToElementSetMap()
 {
     DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<DocumentElementSetMap>, map, (adoptPtrWillBeNoop(new DocumentElementSetMap())));
     return *map;
 }
 
-static void addElementToDocumentMap(HTMLMediaElement* element, Document* document)
+void addElementToDocumentMap(HTMLMediaElement* element, Document* document)
 {
     DocumentElementSetMap& map = documentToElementSetMap();
     WeakMediaElementSet set = map.take(document);
     set.add(element);
     map.add(document, set);
 }
 
-static void removeElementFromDocumentMap(HTMLMediaElement* element, Document* document)
+void removeElementFromDocumentMap(HTMLMediaElement* element, Document* document)
 {
     DocumentElementSetMap& map = documentToElementSetMap();
     WeakMediaElementSet set = map.take(document);
     set.remove(element);
     if (!set.isEmpty())
         map.add(document, set);
 }
 
 class AudioSourceProviderClientLockScope {
     STACK_ALLOCATED();
 public:
     AudioSourceProviderClientLockScope(HTMLMediaElement& element)
         : m_client(element.audioSourceNode())
     {
         if (m_client)
             m_client->lock();
     }
     ~AudioSourceProviderClientLockScope()
     {
         if (m_client)
             m_client->unlock();
     }
 
 private:
     Member<AudioSourceProviderClient> m_client;
 };
 
-static const AtomicString& AudioKindToString(WebMediaPlayerClient::AudioTrackKind kind)
+const AtomicString& AudioKindToString(WebMediaPlayerClient::AudioTrackKind kind)
 {
     switch (kind) {
     case WebMediaPlayerClient::AudioTrackKindNone:
         return emptyAtom;
     case WebMediaPlayerClient::AudioTrackKindAlternative:
         return AudioTrack::alternativeKeyword();
     case WebMediaPlayerClient::AudioTrackKindDescriptions:
         return AudioTrack::descriptionsKeyword();
     case WebMediaPlayerClient::AudioTrackKindMain:
         return AudioTrack::mainKeyword();
     case WebMediaPlayerClient::AudioTrackKindMainDescriptions:
         return AudioTrack::mainDescriptionsKeyword();
     case WebMediaPlayerClient::AudioTrackKindTranslation:
         return AudioTrack::translationKeyword();
     case WebMediaPlayerClient::AudioTrackKindCommentary:
         return AudioTrack::commentaryKeyword();
     }
 
     ASSERT_NOT_REACHED();
     return emptyAtom;
 }
 
-static const AtomicString& VideoKindToString(WebMediaPlayerClient::VideoTrackKind kind)
+const AtomicString& VideoKindToString(WebMediaPlayerClient::VideoTrackKind kind)
 {
     switch (kind) {
     case WebMediaPlayerClient::VideoTrackKindNone:
         return emptyAtom;
     case WebMediaPlayerClient::VideoTrackKindAlternative:
         return VideoTrack::alternativeKeyword();
     case WebMediaPlayerClient::VideoTrackKindCaptions:
         return VideoTrack::captionsKeyword();
     case WebMediaPlayerClient::VideoTrackKindMain:
         return VideoTrack::mainKeyword();
     case WebMediaPlayerClient::VideoTrackKindSign:
         return VideoTrack::signKeyword();
     case WebMediaPlayerClient::VideoTrackKindSubtitles:
         return VideoTrack::subtitlesKeyword();
     case WebMediaPlayerClient::VideoTrackKindCommentary:
         return VideoTrack::commentaryKeyword();
     }
 
     ASSERT_NOT_REACHED();
     return emptyAtom;
 }
 
-static bool canLoadURL(const KURL& url, const ContentType& contentType, const String& keySystem)
+bool canLoadURL(const KURL& url, const ContentType& contentType, const String& keySystem)
 {
     DEFINE_STATIC_LOCAL(const String, codecs, ("codecs"));
 
     String contentMIMEType = contentType.type().lower();
     String contentTypeCodecs = contentType.parameter(codecs);
 
     // If the MIME type is missing or is not meaningful, try to figure it out from the URL.
     if (contentMIMEType.isEmpty() || contentMIMEType == "application/octet-stream" || contentMIMEType == "text/plain") {
         if (url.protocolIsData())
             contentMIMEType = mimeTypeFromDataURL(url.string());
     }
 
     // If no MIME type is specified, always attempt to load.
     if (contentMIMEType.isEmpty())
         return true;
 
     // 4.8.10.3 MIME types - In the absence of a specification to the contrary, the MIME type "application/octet-stream"
     // when used with parameters, e.g. "application/octet-stream;codecs=theora", is a type that the user agent knows
     // it cannot render.
     if (contentMIMEType != "application/octet-stream" || contentTypeCodecs.isEmpty()) {
         WebMimeRegistry::SupportsType supported = Platform::current()->mimeRegistry()->supportsMediaMIMEType(contentMIMEType, contentTypeCodecs, keySystem.lower());
         return supported > WebMimeRegistry::IsNotSupported;
     }
 
     return false;
 }
 
+} // anonymous namespace
+
 void HTMLMediaElement::recordAutoplayMetric(AutoplayMetrics metric)
 {
     DEFINE_STATIC_LOCAL(EnumerationHistogram, autoplayHistogram, ("Blink.MediaElement.Autoplay", NumberOfAutoplayMetrics));
     autoplayHistogram.count(metric);
 }
 
 WebMimeRegistry::SupportsType HTMLMediaElement::supportsType(const ContentType& contentType, const String& keySystem)
 {
     DEFINE_STATIC_LOCAL(const String, codecs, ("codecs"));
 
@@ skipping 3377 matching lines @@
 {
     visitor->trace(m_client);
 }
 
 DEFINE_TRACE(HTMLMediaElement::AudioSourceProviderImpl)
 {
     visitor->trace(m_client);
 }
 
 } // namespace blink