blink: m_foo -> foo_ in logging strings.

third_party/WebKit/Source/core/loader/ImageLoader.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010 Apple Inc. All rights
  * reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 153 matching lines @@
       element_is_protected_(false),
       suppress_error_events_(false) {
   RESOURCE_LOADING_DVLOG(1) << "new ImageLoader " << this;
 }
 
 ImageLoader::~ImageLoader() {}
 
 void ImageLoader::Dispose() {
   RESOURCE_LOADING_DVLOG(1)
       << "~ImageLoader " << this
-      << "; m_hasPendingLoadEvent=" << has_pending_load_event_
-      << ", m_hasPendingErrorEvent=" << has_pending_error_event_;
+      << "; has_pending_load_event_=" << has_pending_load_event_
+      << ", has_pending_error_event_=" << has_pending_error_event_;
 
   if (image_) {
     image_->RemoveObserver(this);
     image_ = nullptr;
   }
 }
 
 DEFINE_TRACE(ImageLoader) {
   visitor->Trace(image_);
   visitor->Trace(image_resource_for_image_document_);
@@ skipping 86 matching lines @@
                                       UpdateFromElementBehavior update_behavior,
                                       const KURL& url,
                                       ReferrerPolicy referrer_policy) {
   // FIXME: According to
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/embedded-content.html#the-img-element:the-img-element-55
   // When "update image" is called due to environment changes and the load
   // fails, onerror should not be called. That is currently not the case.
   //
   // We don't need to call clearLoader here: Either we were called from the
   // task, or our caller updateFromElement cleared the task's loader (and set
-  // m_pendingTask to null).
+  // pending_task_ to null).
   pending_task_.reset();
   // Make sure to only decrement the count when we exit this function
   std::unique_ptr<IncrementLoadEventDelayCount> load_delay_counter;
   load_delay_counter.swap(load_delay_counter_);
 
   Document& document = element_->GetDocument();
   if (!document.IsActive())
     return;
 
   AtomicString image_source_url = element_->ImageSourceURL();
@@ skipping 47 matching lines @@
       element_->GetLayoutObject()->IsImage() && new_image == old_image) {
     ToLayoutImage(element_->GetLayoutObject())->IntrinsicSizeChanged();
   } else {
     if (has_pending_load_event_) {
       LoadEventSender().CancelEvent(this);
       has_pending_load_event_ = false;
     }
 
     // Cancel error events that belong to the previous load, which is now
     // cancelled by changing the src attribute. If newImage is null and
-    // m_hasPendingErrorEvent is true, we know the error event has been just
+    // has_pending_error_event_ is true, we know the error event has been just
     // posted by this load and we should not cancel the event.
     // FIXME: If both previous load and this one got blocked with an error, we
     // can receive one error event instead of two.
     if (has_pending_error_event_ && new_image) {
       ErrorEventSender().CancelEvent(this);
       has_pending_error_event_ = false;
     }
 
     image_ = new_image;
     has_pending_load_event_ = new_image;
@@ skipping 27 matching lines @@
 
   if (update_behavior == kUpdateIgnorePreviousError)
     ClearFailedLoadURL();
 
   if (!failed_load_url_.IsEmpty() && image_source_url == failed_load_url_)
     return;
 
   // Prevent the creation of a ResourceLoader (and therefore a network request)
   // for ImageDocument loads. In this case, the image contents have already been
   // requested as a main resource and ImageDocumentParser will take care of
-  // funneling the main resource bytes into m_image, so just create an
+  // funneling the main resource bytes into image_, so just create an
   // ImageResource to be populated later.
   if (loading_image_document_ && update_behavior != kUpdateForcedReload) {
     ImageResource* image_resource = ImageResource::Create(
         ResourceRequest(ImageSourceToKURL(element_->ImageSourceURL())));
     image_resource->SetStatus(ResourceStatus::kPending);
     image_resource->NotifyStartLoad();
     image_resource_for_image_document_ = image_resource;
     SetImage(image_resource->GetContent());
     return;
   }
@@ skipping 57 matching lines @@
         url, element_->GetDocument().Fetcher()->GetCacheIdentifier());
     if (resource && !resource->ErrorOccurred())
       return true;
   }
   return (isHTMLObjectElement(element_) || isHTMLEmbedElement(element_));
 }
 
 void ImageLoader::ImageNotifyFinished(ImageResourceContent* resource) {
   RESOURCE_LOADING_DVLOG(1)
       << "ImageLoader::imageNotifyFinished " << this
-      << "; m_hasPendingLoadEvent=" << has_pending_load_event_;
+      << "; has_pending_load_event_=" << has_pending_load_event_;
 
   DCHECK(failed_load_url_.IsEmpty());
   DCHECK_EQ(resource, image_.Get());
 
   image_complete_ = true;
 
-  // Update ImageAnimationPolicy for m_image.
+  // Update ImageAnimationPolicy for image_.
   if (image_)
     image_->UpdateImageAnimationPolicy();
 
   UpdateLayoutObject();
 
   if (image_ && image_->GetImage() && image_->GetImage()->IsSVGImage())
     ToSVGImage(image_->GetImage())
         ->UpdateUseCounters(GetElement()->GetDocument());
 
   if (!has_pending_load_event_)
@@ skipping 142 matching lines @@
 }
 
 void ImageLoader::ElementDidMoveToNewDocument() {
   if (load_delay_counter_)
     load_delay_counter_->DocumentChanged(element_->GetDocument());
   ClearFailedLoadURL();
   SetImage(0);
 }
 
 }  // namespace blink