blink: m_foo -> foo_ in logging strings.

third_party/WebKit/Source/platform/loader/fetch/Resource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 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
@@ skipping 256 matching lines @@
 Resource::ResourceCallback& Resource::ResourceCallback::CallbackHandler() {
   DEFINE_STATIC_LOCAL(ResourceCallback, callback_handler, ());
   return callback_handler;
 }
 
 Resource::ResourceCallback::ResourceCallback() {}
 
 void Resource::ResourceCallback::Schedule(Resource* resource) {
   if (!task_handle_.IsActive()) {
     // WTF::unretained(this) is safe because a posted task is canceled when
-    // |m_taskHandle| is destroyed on the dtor of this ResourceCallback.
+    // |task_handle_| is destroyed on the dtor of this ResourceCallback.
     task_handle_ =
         Platform::Current()
             ->CurrentThread()
             ->Scheduler()
             ->LoadingTaskRunner()
             ->PostCancellableTask(
                 BLINK_FROM_HERE,
                 WTF::Bind(&ResourceCallback::RunTask, WTF::Unretained(this)));
   }
   resources_with_pending_clients_.insert(resource);
@@ skipping 343 matching lines @@
     }
     if (!finished_clients_.IsEmpty()) {
       builder.Append(", Finished=");
       builder.AppendNumber(finished_clients_.size());
     }
     builder.Append(')');
   }
   if (loader_) {
     if (!builder.IsEmpty())
       builder.Append(' ');
-    builder.Append("m_loader");
+    builder.Append("loader_");
   }
   if (preload_count_) {
     if (!builder.IsEmpty())
       builder.Append(' ');
-    builder.Append("m_preloadCount(");
+    builder.Append("preload_count_(");
     builder.AppendNumber(preload_count_);
     builder.Append(')');
   }
   if (GetMemoryCache()->Contains(this)) {
     if (!builder.IsEmpty())
       builder.Append(' ');
     builder.Append("in_memory_cache");
   }
   return builder.ToString();
 }
@@ skipping 144 matching lines @@
 void Resource::FinishPendingClients() {
   // We're going to notify clients one by one. It is simple if the client does
   // nothing. However there are a couple other things that can happen.
   //
   // 1. Clients can be added during the loop. Make sure they are not processed.
   // 2. Clients can be removed during the loop. Make sure they are always
   //    available to be removed. Also don't call removed clients or add them
   //    back.
   //
   // Handle case (1) by saving a list of clients to notify. A separate list also
-  // ensure a client is either in m_clients or m_clientsAwaitingCallback.
+  // ensure a client is either in cliens_ or clients_awaiting_callback_.
   HeapVector<Member<ResourceClient>> clients_to_notify;
   CopyToVector(clients_awaiting_callback_, clients_to_notify);
 
   for (const auto& client : clients_to_notify) {
     // Handle case (2) to skip removed clients.
     if (!clients_awaiting_callback_.erase(client))
       continue;
     clients_.insert(client);
 
     // When revalidation starts after waiting clients are scheduled and
     // before they are added here. In such cases, we just add the clients
-    // to |m_clients| without didAddClient(), as in Resource::addClient().
+    // to |clients_| without DidAddClient(), as in Resource::AddClient().
     if (!is_revalidating_)
       DidAddClient(client);
   }
 
   // It is still possible for the above loop to finish a new client
   // synchronously. If there's no client waiting we should deschedule.
   bool scheduled = ResourceCallback::CallbackHandler().IsScheduled(this);
   if (scheduled && clients_awaiting_callback_.IsEmpty())
     ResourceCallback::CallbackHandler().Cancel(this);
 
@@ skipping 286 matching lines @@
     case Resource::kMedia:
     case Resource::kManifest:
     case Resource::kMock:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace blink