blink: m_foo -> foo_ in logging strings.

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
@@ skipping 507 matching lines @@
 
   SetHasCustomStyleCallbacks();
   AddElementToDocumentMap(this, &document);
 
   UseCounter::Count(document, UseCounter::kHTMLMediaElement);
 }
 
 HTMLMediaElement::~HTMLMediaElement() {
   BLINK_MEDIA_LOG << "~HTMLMediaElement(" << (void*)this << ")";
 
-  // m_audioSourceNode is explicitly cleared by AudioNode::dispose().
+  // audio_source_node_ is explicitly cleared by AudioNode::dispose().
   // Since AudioNode::dispose() is guaranteed to be always called before
-  // the AudioNode is destructed, m_audioSourceNode is explicitly cleared
+  // the AudioNode is destructed, audio_source_node_ is explicitly cleared
   // even if the AudioNode and the HTMLMediaElement die together.
   DCHECK(!audio_source_node_);
 }
 
 void HTMLMediaElement::Dispose() {
   CloseMediaSource();
 
   // Destroying the player may cause a resource load to be canceled,
   // which could result in LocalDOMWindow::dispatchWindowLoadEvent() being
   // called via ResourceFetch::didLoadResource(), then
@@ skipping 20 matching lines @@
   check_viewport_intersection_timer_.MoveToNewTaskRunner(
       TaskRunnerHelper::Get(TaskType::kUnthrottled, &GetDocument()));
   deferred_load_timer_.MoveToNewTaskRunner(
       TaskRunnerHelper::Get(TaskType::kUnthrottled, &GetDocument()));
 
   autoplay_policy_->DidMoveToNewDocument(old_document);
 
   if (should_delay_load_event_) {
     GetDocument().IncrementLoadEventDelayCount();
     // Note: Keeping the load event delay count increment on oldDocument that
-    // was added when m_shouldDelayLoadEvent was set so that destruction of
-    // m_webMediaPlayer can not cause load event dispatching in oldDocument.
+    // was added when should_delay_load_event_ was set so that destruction of
+    // web_media_player_ can not cause load event dispatching in oldDocument.
   } else {
     // Incrementing the load event delay count so that destruction of
-    // m_webMediaPlayer can not cause load event dispatching in oldDocument.
+    // web_media_player_ can not cause load event dispatching in oldDocument.
     old_document.IncrementLoadEventDelayCount();
   }
 
   RemoveElementFromDocumentMap(this, &old_document);
   AddElementToDocumentMap(this, &GetDocument());
 
   // FIXME: This is a temporary fix to prevent this object from causing the
   // MediaPlayer to dereference LocalFrame and FrameLoader pointers from the
   // previous document. This restarts the load, as if the src attribute had been
   // set.  A proper fix would provide a mechanism to allow this object to
   // refresh the MediaPlayer's LocalFrame and FrameLoader references on document
   // changes so that playback can be resumed properly.
   ignore_preload_none_ = false;
   InvokeLoadAlgorithm();
 
   // Decrement the load event delay count on oldDocument now that
-  // m_webMediaPlayer has been destroyed and there is no risk of dispatching a
+  // web_media_player_ has been destroyed and there is no risk of dispatching a
   // load event from within the destructor.
   old_document.DecrementLoadEventDelayCount();
 
   SuspendableObject::DidMoveToNewExecutionContext(&GetDocument());
   HTMLElement::DidMoveToNewDocument(old_document);
 }
 
 bool HTMLMediaElement::SupportsFocus() const {
   if (ownerDocument()->IsMediaDocument())
     return false;
@@ skipping 125 matching lines @@
   pending_action_flags_ |= kLoadMediaResource;
   load_timer_.StartOneShot(0, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::ScheduleEvent(const AtomicString& event_name) {
   ScheduleEvent(Event::CreateCancelable(event_name));
 }
 
 void HTMLMediaElement::ScheduleEvent(Event* event) {
 #if LOG_MEDIA_EVENTS
-  BLINK_MEDIA_LOG << "scheduleEvent(" << (void*)this << ")"
+  BLINK_MEDIA_LOG << "ScheduleEvent(" << (void*)this << ")"
                   << " - scheduling '" << event->type() << "'";
 #endif
   async_event_queue_->EnqueueEvent(event);
 }
 
 void HTMLMediaElement::LoadTimerFired(TimerBase*) {
   if (pending_action_flags_ & kLoadTextTrackResource)
     HonorUserPreferencesForAutomaticTextTrackSelection();
 
   if (pending_action_flags_ & kLoadMediaResource) {
@@ skipping 50 matching lines @@
 
 void HTMLMediaElement::load() {
   BLINK_MEDIA_LOG << "load(" << (void*)this << ")";
 
   autoplay_policy_->TryUnlockingUserGesture();
 
   ignore_preload_none_ = true;
   InvokeLoadAlgorithm();
 }
 
-// TODO(srirama.m): Currently m_ignorePreloadNone is reset before calling
+// TODO(srirama.m): Currently ignore_preload_none_ is reset before calling
 // invokeLoadAlgorithm() in all places except load(). Move it inside here
 // once microtask is implemented for "Await a stable state" step
 // in resource selection algorithm.
 void HTMLMediaElement::InvokeLoadAlgorithm() {
   BLINK_MEDIA_LOG << "invokeLoadAlgorithm(" << (void*)this << ")";
 
   // Perform the cleanup required for the resource load algorithm to run.
   StopPeriodicTimers();
   load_timer_.Stop();
   CancelDeferredLoad();
   // FIXME: Figure out appropriate place to reset LoadTextTrackResource if
-  // necessary and set m_pendingActionFlags to 0 here.
+  // necessary and set pending_action_flags_ to 0 here.
   pending_action_flags_ &= ~kLoadMediaResource;
   sent_stalled_event_ = false;
   have_fired_loaded_data_ = false;
   display_mode_ = kUnknown;
 
   // 1 - Abort any already-running instance of the resource selection algorithm
   // for this element.
   load_state_ = kWaitingForSource;
   current_source_node_ = nullptr;
 
@@ skipping 110 matching lines @@
   BLINK_MEDIA_LOG << "invokeResourceSelectionAlgorithm(" << (void*)this << ")";
   // The resource selection algorithm
   // 1 - Set the networkState to NETWORK_NO_SOURCE
   SetNetworkState(kNetworkNoSource);
 
   // 2 - Set the element's show poster flag to true
   // TODO(srirama.m): Introduce show poster flag and update it as per spec
 
   played_time_ranges_ = TimeRanges::Create();
 
-  // FIXME: Investigate whether these can be moved into m_networkState !=
+  // FIXME: Investigate whether these can be moved into network_state_ !=
   // kNetworkEmpty block above
   // so they are closer to the relevant spec steps.
   last_seek_time_ = 0;
   duration_ = std::numeric_limits<double>::quiet_NaN();
 
   // 3 - Set the media element's delaying-the-load-event flag to true (this
   // delays the load event)
   SetShouldDelayLoadEvent(true);
   if (GetMediaControls())
     GetMediaControls()->Reset();
@@ skipping 154 matching lines @@
   if (!frame) {
     MediaLoadingFailed(WebMediaPlayer::kNetworkStateFormatError,
                        BuildElementErrorMessage(
                            "Resource load failure: document has no frame"));
     return;
   }
 
   // The resource fetch algorithm
   SetNetworkState(kNetworkLoading);
 
-  // Set m_currentSrc *before* changing to the cache url, the fact that we are
+  // Set current_src_ *before* changing to the cache url, the fact that we are
   // loading from the app cache is an internal detail not exposed through the
   // media element API.
   current_src_ = url;
 
   if (audio_source_node_)
     audio_source_node_->OnCurrentSrcChanged(current_src_);
 
-  BLINK_MEDIA_LOG << "loadResource(" << (void*)this << ") - m_currentSrc -> "
+  BLINK_MEDIA_LOG << "loadResource(" << (void*)this << ") - current_src_ -> "
                   << UrlForLoggingMedia(current_src_);
 
   StartProgressEventTimer();
 
   // Reset display mode to force a recalculation of what to show because we are
   // resetting the player.
   SetDisplayMode(kUnknown);
 
   SetPlayerPreload();
 
@@ skipping 531 matching lines @@
 
 void HTMLMediaElement::ReadyStateChanged() {
   SetReadyState(static_cast<ReadyState>(GetWebMediaPlayer()->GetReadyState()));
 }
 
 void HTMLMediaElement::SetReadyState(ReadyState state) {
   BLINK_MEDIA_LOG << "setReadyState(" << (void*)this << ", "
                   << static_cast<int>(state) << ") - current state is "
                   << static_cast<int>(ready_state_);
 
-  // Set "wasPotentiallyPlaying" BEFORE updating m_readyState,
+  // Set "wasPotentiallyPlaying" BEFORE updating ready_state_,
   // potentiallyPlaying() uses it
   bool was_potentially_playing = PotentiallyPlaying();
 
   ReadyState old_state = ready_state_;
   ReadyState new_state = state;
 
   bool tracks_are_ready = TextTracksAreReady();
 
   if (new_state == old_state && tracks_are_ready_ == tracks_are_ready)
     return;
@@ skipping 25 matching lines @@
     // will be fired at the element.
     if (was_potentially_playing && ready_state_ < kHaveFutureData)
       ScheduleEvent(EventTypeNames::waiting);
 
     // 4.8.12.9 steps 12-14
     if (ready_state_ >= kHaveCurrentData)
       FinishSeek();
   } else {
     if (was_potentially_playing && ready_state_ < kHaveFutureData) {
       // Force an update to official playback position. Automatic updates from
-      // currentPlaybackPosition() will be blocked while m_readyState remains
+      // currentPlaybackPosition() will be blocked while ready_state_ remains
       // < kHaveFutureData. This blocking is desired after 'waiting' has been
       // fired, but its good to update it one final time to accurately reflect
       // media time at the moment we ran out of data to play.
       SetOfficialPlaybackPosition(CurrentPlaybackPosition());
 
       // 4.8.12.8
       ScheduleTimeupdateEvent(false);
       ScheduleEvent(EventTypeNames::waiting);
     }
   }
@@ skipping 127 matching lines @@
 void HTMLMediaElement::SetIgnorePreloadNone() {
   BLINK_MEDIA_LOG << "setIgnorePreloadNone(" << (void*)this << ")";
   ignore_preload_none_ = true;
   SetPlayerPreload();
 }
 
 void HTMLMediaElement::Seek(double time) {
   BLINK_MEDIA_LOG << "seek(" << (void*)this << ", " << time << ")";
 
   // 2 - If the media element's readyState is HAVE_NOTHING, abort these steps.
-  // FIXME: remove m_webMediaPlayer check once we figure out how
-  // m_webMediaPlayer is going out of sync with readystate.
-  // m_webMediaPlayer is cleared but readystate is not set to HAVE_NOTHING.
+  // FIXME: remove web_media_player_ check once we figure out how
+  // web_media_player_ is going out of sync with readystate.
+  // web_media_player_ is cleared but readystate is not set to HAVE_NOTHING.
   if (!web_media_player_ || ready_state_ == kHaveNothing)
     return;
 
   // Ignore preload none and start load if necessary.
   SetIgnorePreloadNone();
 
-  // Get the current time before setting m_seeking, m_lastSeekTime is returned
+  // Get the current time before setting seeking_, last_seek_time_ is returned
   // once it is set.
   double now = currentTime();
 
   // 3 - If the element's seeking IDL attribute is true, then another instance
   // of this algorithm is already running. Abort that other instance of the
   // algorithm without waiting for the step that it is running to complete.
   // Nothing specific to be done here.
 
   // 4 - Set the seeking IDL attribute to true.
   // The flag will be cleared when the engine tells us the time has actually
   // changed.
   seeking_ = true;
 
   // 6 - If the new playback position is later than the end of the media
   // resource, then let it be the end of the media resource instead.
   time = std::min(time, duration());
 
   // 7 - If the new playback position is less than the earliest possible
   // position, let it be that position instead.
   time = std::max(time, EarliestPossiblePosition());
 
   // Ask the media engine for the time value in the movie's time scale before
   // comparing with current time. This is necessary because if the seek time is
   // not equal to currentTime but the delta is less than the movie's time scale,
   // we will ask the media engine to "seek" to the current movie time, which may
-  // be a noop and not generate a timechanged callback. This means m_seeking
+  // be a noop and not generate a timechanged callback. This means seeking_
   // will never be cleared and we will never fire a 'seeked' event.
   double media_time = GetWebMediaPlayer()->MediaTimeForTimeValue(time);
   if (time != media_time) {
     BLINK_MEDIA_LOG << "seek(" << (void*)this << ", " << time
                     << ") - media timeline equivalent is " << media_time;
     time = media_time;
   }
 
   // 8 - If the (possibly now changed) new playback position is not in one of
   // the ranges given in the seekable attribute, then let it be the position in
@@ skipping 66 matching lines @@
 double HTMLMediaElement::EarliestPossiblePosition() const {
   TimeRanges* seekable_ranges = seekable();
   if (seekable_ranges && seekable_ranges->length() > 0)
     return seekable_ranges->start(0, ASSERT_NO_EXCEPTION);
 
   return CurrentPlaybackPosition();
 }
 
 double HTMLMediaElement::CurrentPlaybackPosition() const {
   // "Official" playback position won't take updates from "current" playback
-  // position until m_readyState > kHaveMetadata, but other callers (e.g.
+  // position until ready_state_ > kHaveMetadata, but other callers (e.g.
   // pauseInternal) may still request currentPlaybackPosition at any time.
   // From spec: "Media elements have a current playback position, which must
   // initially (i.e., in the absence of media data) be zero seconds."
   if (ready_state_ == kHaveNothing)
     return 0;
 
   if (GetWebMediaPlayer())
     return GetWebMediaPlayer()->CurrentTime();
 
   if (ready_state_ >= kHaveMetadata) {
@@ skipping 11 matching lines @@
   // currentTime (e.g. as samples in the last rendered audio buffer are played
   // played out), but advancing currentTime while paused/waiting sends a mixed
   // signal about the state of playback.
   bool waiting_for_data = ready_state_ <= kHaveCurrentData;
   if (official_playback_position_needs_update_ && !paused_ &&
       !waiting_for_data) {
     SetOfficialPlaybackPosition(CurrentPlaybackPosition());
   }
 
 #if LOG_OFFICIAL_TIME_STATUS
-  static const double minCachedDeltaForWarning = 0.01;
+  static const double kMinCachedDeltaForWarning = 0.01;
   double delta =
-      std::abs(m_officialPlaybackPosition - currentPlaybackPosition());
-  if (delta > minCachedDeltaForWarning) {
-    BLINK_MEDIA_LOG << "currentTime(" << (void*)this
+      std::abs(official_playback_position_ - CurrentPlaybackPosition());
+  if (delta > kMinCachedDeltaForWarning) {
+    BLINK_MEDIA_LOG << "CurrentTime(" << (void*)this
                     << ") - WARNING, cached time is " << delta
                     << "seconds off of media time when paused/waiting";
   }
 #endif
 
   return official_playback_position_;
 }
 
 void HTMLMediaElement::SetOfficialPlaybackPosition(double position) const {
 #if LOG_OFFICIAL_TIME_STATUS
-  BLINK_MEDIA_LOG << "setOfficialPlaybackPosition(" << (void*)this
-                  << ") was:" << m_officialPlaybackPosition
+  BLINK_MEDIA_LOG << "SetOfficialPlaybackPosition(" << (void*)this
+                  << ") was:" << official_playback_position_
                   << " now:" << position;
 #endif
 
   // Internal player position may advance slightly beyond duration because
   // many files use imprecise duration. Clamp official position to duration when
   // known. Duration may be unknown when readyState < HAVE_METADATA.
   official_playback_position_ =
       std::isnan(duration()) ? position : std::min(duration(), position);
 
   if (official_playback_position_ != position) {
@@ skipping 75 matching lines @@
 
   UpdatePlaybackRate();
 }
 
 HTMLMediaElement::DirectionOfPlayback HTMLMediaElement::GetDirectionOfPlayback()
     const {
   return playback_rate_ >= 0 ? kForward : kBackward;
 }
 
 void HTMLMediaElement::UpdatePlaybackRate() {
-  // FIXME: remove m_webMediaPlayer check once we figure out how
-  // m_webMediaPlayer is going out of sync with readystate.
-  // m_webMediaPlayer is cleared but readystate is not set to kHaveNothing.
+  // FIXME: remove web_media_player_ check once we figure out how
+  // web_media_player_ is going out of sync with readystate.
+  // web_media_player_ is cleared but readystate is not set to kHaveNothing.
   if (web_media_player_ && PotentiallyPlaying())
     GetWebMediaPlayer()->SetRate(playbackRate());
 }
 
 bool HTMLMediaElement::ended() const {
   // 4.8.12.8 Playing the media resource
   // The ended attribute must return true if the media element has ended
   // playback and the direction of playback is forwards, and false otherwise.
   return EndedPlayback() && GetDirectionOfPlayback() == kForward;
 }
@@ skipping 72 matching lines @@
   WebMediaPlayer::Preload preload = PreloadType();
   if (ignore_preload_none_ && preload == WebMediaPlayer::kPreloadNone)
     return WebMediaPlayer::kPreloadMetaData;
 
   return preload;
 }
 
 ScriptPromise HTMLMediaElement::playForBindings(ScriptState* script_state) {
   // We have to share the same logic for internal and external callers. The
   // internal callers do not want to receive a Promise back but when ::play()
-  // is called, |m_playPromiseResolvers| needs to be populated. What this code
-  // does is to populate |m_playPromiseResolvers| before calling ::play() and
+  // is called, |play_promise_resolvers_| needs to be populated. What this code
+  // does is to populate |play_promise_resolvers_| before calling ::play() and
   // remove the Promise if ::play() failed.
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
   play_promise_resolvers_.push_back(resolver);
 
   Nullable<ExceptionCode> code = Play();
   if (!code.IsNull()) {
     DCHECK(!play_promise_resolvers_.IsEmpty());
     play_promise_resolvers_.pop_back();
 
@@ skipping 92 matching lines @@
     InvokeResourceSelectionAlgorithm();
 
   can_autoplay_ = false;
 
   if (!paused_) {
     paused_ = true;
     ScheduleTimeupdateEvent(false);
     ScheduleEvent(EventTypeNames::pause);
 
     // Force an update to official playback position. Automatic updates from
-    // currentPlaybackPosition() will be blocked while m_paused = true. This
+    // currentPlaybackPosition() will be blocked while paused_ = true. This
     // blocking is desired while paused, but its good to update it one final
     // time to accurately reflect movie time at the moment we paused.
     SetOfficialPlaybackPosition(CurrentPlaybackPosition());
 
     ScheduleRejectPlayPromises(kAbortError);
   }
 
   UpdatePlayState();
 }
 
@@ skipping 613 matching lines @@
   // at all.
   if (FastHasAttribute(srcAttr))
     return;
 
   // 4.8.8 - If a source element is inserted as a child of a media element that
   // has no src attribute and whose networkState has the value NETWORK_EMPTY,
   // the user agent must invoke the media element's resource selection
   // algorithm.
   if (getNetworkState() == HTMLMediaElement::kNetworkEmpty) {
     InvokeResourceSelectionAlgorithm();
-    // Ignore current |m_nextChildNodeToConsider| and consider |source|.
+    // Ignore current |next_child_node_to_consider_| and consider |source|.
     next_child_node_to_consider_ = source;
     return;
   }
 
   if (current_source_node_ && source == current_source_node_->nextSibling()) {
     BLINK_MEDIA_LOG << "sourceWasAdded(" << (void*)this
                     << ") - <source> inserted immediately after current source";
-    // Ignore current |m_nextChildNodeToConsider| and consider |source|.
+    // Ignore current |next_child_node_to_consider_| and consider |source|.
     next_child_node_to_consider_ = source;
     return;
   }
 
-  // Consider current |m_nextChildNodeToConsider| as it is already in the middle
-  // of processing.
+  // Consider current |next_child_node_to_consider_| as it is already in the
+  // middle of processing.
   if (next_child_node_to_consider_)
     return;
 
   if (load_state_ != kWaitingForSource)
     return;
 
   // 4.8.9.5, resource selection algorithm, source elements section:
   // 21. Wait until the node after pointer is a node other than the end of the
   // list. (This step might wait forever.)
   // 22. Asynchronously await a stable state...
@@ skipping 17 matching lines @@
   BLINK_MEDIA_LOG << "sourceWasRemoved(" << (void*)this << ") - 'src' is "
                   << UrlForLoggingMedia(url);
 
   if (source != current_source_node_ && source != next_child_node_to_consider_)
     return;
 
   if (source == next_child_node_to_consider_) {
     if (current_source_node_)
       next_child_node_to_consider_ = current_source_node_->nextSibling();
     BLINK_MEDIA_LOG << "sourceWasRemoved(" << (void*)this
-                    << ") - m_nextChildNodeToConsider set to "
+                    << ") - next_child_node_to_consider_ set to "
                     << next_child_node_to_consider_.Get();
   } else if (source == current_source_node_) {
     // Clear the current source node pointer, but don't change the movie as the
     // spec says:
     // 4.8.8 - Dynamically modifying a source element and its attribute when the
     // element is already inserted in a video or audio element will have no
     // effect.
     current_source_node_ = nullptr;
-    BLINK_MEDIA_LOG << "sourceWasRemoved(" << (void*)this
-                    << ") - m_currentSourceNode set to 0";
+    BLINK_MEDIA_LOG << "SourceWasRemoved(" << (void*)this
+                    << ") - current_source_node_ set to 0";
   }
 }
 
 void HTMLMediaElement::TimeChanged() {
   BLINK_MEDIA_LOG << "timeChanged(" << (void*)this << ")";
 
   GetCueTimeline().UpdateActiveCues(currentTime());
 
   // 4.8.12.9 steps 12-14. Needed if no ReadyState change is associated with the
   // seek.
@@ skipping 1018 matching lines @@
       kMostlyFillViewportBecomeStableSeconds, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::ViewportFillDebouncerTimerFired(TimerBase*) {
   mostly_filling_viewport_ = true;
   if (web_media_player_)
     web_media_player_->BecameDominantVisibleContent(mostly_filling_viewport_);
 }
 
 }  // namespace blink