Convert LOG(INFO) to VLOG(1) - chrome/common/.

chrome/common/resource_dispatcher.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "chrome/common/resource_dispatcher.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/shared_memory.h"
 #include "base/string_util.h"
 #include "chrome/common/extensions/extension_localization_peer.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/render_messages_params.h"
 #include "chrome/common/resource_response.h"
 #include "chrome/common/security_filter_peer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_response_headers.h"
 #include "webkit/glue/resource_type.h"
 #include "webkit/glue/webkit_glue.h"
 
-// Uncomment to enable logging of request traffic
-// #define LOG_RESOURCE_REQUESTS
-
-#ifdef LOG_RESOURCE_REQUESTS
-# define RESOURCE_LOG(stuff) LOG(INFO) << stuff
-#else
-# define RESOURCE_LOG(stuff)
-#endif
-
 // Each resource request is assigned an ID scoped to this process.
 static int MakeRequestID() {
   // NOTE: The resource_dispatcher_host also needs probably unique
   // request_ids, so they count down from -2 (-1 is a special we're
   // screwed value), while the renderer process counts up.
   static int next_request_id = 0;
   return next_request_id++;
 }
 
 // ResourceLoaderBridge implementation ----------------------------------------
@@ skipping 15 matching lines @@
       uint64 offset,
       uint64 length,
       const base::Time& expected_modification_time);
   virtual void AppendBlobToUpload(const GURL& blob_url);
   virtual void SetUploadIdentifier(int64 identifier);
   virtual bool Start(Peer* peer);
   virtual void Cancel();
   virtual void SetDefersLoading(bool value);
   virtual void SyncLoad(SyncLoadResponse* response);
 
-#ifdef LOG_RESOURCE_REQUESTS
-  const std::string& url() const { return url_; }
-#endif
-
  private:
   ResourceLoaderBridge::Peer* peer_;
 
   // The resource dispatcher for this loader.  The bridge doesn't own it, but
   // it's guaranteed to outlive the bridge.
   ResourceDispatcher* dispatcher_;
 
   // The request to send, created on initialization for modification and
   // appending data.
   ViewHostMsg_Resource_Request request_;
 
   // ID for the request, valid once Start()ed, -1 if not valid yet.
   int request_id_;
 
   // The routing id used when sending IPC messages.
   int routing_id_;
 
-#ifdef LOG_RESOURCE_REQUESTS
-  // indicates the URL of this resource request for help debugging
-  std::string url_;
-#endif
-
   // The following two members are specified if the request is initiated by
   // a plugin like Gears.
 
   // Contains the id of the host renderer.
   int host_renderer_id_;
 
   // Contains the id of the host render view.
   int host_render_view_id_;
 };
 
@@ skipping 17 matching lines @@
   request_.main_frame_origin = request_info.main_frame_origin;
   request_.headers = request_info.headers;
   request_.load_flags = request_info.load_flags;
   request_.origin_child_id = request_info.requestor_pid;
   request_.resource_type = request_info.request_type;
   request_.request_context = request_info.request_context;
   request_.appcache_host_id = request_info.appcache_host_id;
   request_.download_to_file = request_info.download_to_file;
   request_.host_renderer_id = host_renderer_id_;
   request_.host_render_view_id = host_render_view_id_;
-
-#ifdef LOG_RESOURCE_REQUESTS
-  url_ = request_.url.possibly_invalid_spec();
-#endif
 }
 
 IPCResourceLoaderBridge::~IPCResourceLoaderBridge() {
   // we remove our hook for the resource dispatcher only when going away, since
   // it doesn't keep track of whether we've force terminated the request
   if (request_id_ >= 0) {
     // this operation may fail, as the dispatcher will have preemptively
     // removed us when the renderer sends the ReceivedAllData message.
     dispatcher_->RemovePendingRequest(request_id_);
 
@@ skipping 44 matching lines @@
   request_.upload_data->set_identifier(identifier);
 }
 
 // Writes a footer on the message and sends it
 bool IPCResourceLoaderBridge::Start(Peer* peer) {
   if (request_id_ != -1) {
     NOTREACHED() << "Starting a request twice";
     return false;
   }
 
-  RESOURCE_LOG("Starting request for " << url_);
-
   peer_ = peer;
 
   // generate the request ID, and append it to the message
   request_id_ = dispatcher_->AddPendingRequest(
       peer_, request_.resource_type, request_.url);
 
   return dispatcher_->message_sender()->Send(
       new ViewHostMsg_RequestResource(routing_id_, request_id_, request_));
 }
 
 void IPCResourceLoaderBridge::Cancel() {
   if (request_id_ < 0) {
     NOTREACHED() << "Trying to cancel an unstarted request";
     return;
   }
 
-  RESOURCE_LOG("Canceling request for " << url_);
-
   dispatcher_->CancelPendingRequest(routing_id_, request_id_);
 
   // We can't remove the request ID from the resource dispatcher because more
   // data might be pending. Sending the cancel message may cause more data
   // to be flushed, and will then cause a complete message to be sent.
 }
 
 void IPCResourceLoaderBridge::SetDefersLoading(bool value) {
   if (request_id_ < 0) {
     NOTREACHED() << "Trying to (un)defer an unstarted request";
     return;
   }
 
   dispatcher_->SetDefersLoading(request_id_, value);
 }
 
 void IPCResourceLoaderBridge::SyncLoad(SyncLoadResponse* response) {
   if (request_id_ != -1) {
     NOTREACHED() << "Starting a request twice";
     response->status.set_status(URLRequestStatus::FAILED);
     return;
   }
 
-  RESOURCE_LOG("Making sync request for " << url_);
-
   request_id_ = MakeRequestID();
 
   SyncLoadResult result;
   IPC::SyncMessage* msg = new ViewHostMsg_SyncLoad(routing_id_, request_id_,
                                                    request_, &result);
   // NOTE: This may pump events (see RenderThread::Send).
   if (!dispatcher_->message_sender()->Send(msg)) {
     response->status.set_status(URLRequestStatus::FAILED);
     return;
   }
@@ skipping 79 matching lines @@
   }
   return &(it->second);
 }
 
 void ResourceDispatcher::OnUploadProgress(
     const IPC::Message& message, int request_id, int64 position, int64 size) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
-  RESOURCE_LOG("Dispatching upload progress for " <<
-      request_info->peer->GetURLForDebugging().possibly_invalid_spec());
   request_info->peer->OnUploadProgress(position, size);
 
   // Acknowledge receipt
   message_sender()->Send(
       new ViewHostMsg_UploadProgress_ACK(message.routing_id(), request_id));
 }
 
 void ResourceDispatcher::OnReceivedResponse(
     int request_id, const ResourceResponseHead& response_head) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   if (response_head.replace_extension_localization_templates) {
     webkit_glue::ResourceLoaderBridge::Peer* new_peer =
         ExtensionLocalizationPeer::CreateExtensionLocalizationPeer(
             request_info->peer, message_sender(), response_head.mime_type,
             request_info->url);
     if (new_peer)
       request_info->peer = new_peer;
   }
 
-  RESOURCE_LOG("Dispatching response for " <<
-      request_info->peer->GetURLForDebugging().possibly_invalid_spec());
   request_info->peer->OnReceivedResponse(response_head, false);
 }
 
 void ResourceDispatcher::OnReceivedCachedMetadata(
       int request_id, const std::vector<char>& data) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
-  if (data.size()) {
-    RESOURCE_LOG("Dispatching " << data.size() << " metadata bytes for " <<
-        request_info->peer->GetURLForDebugging().possibly_invalid_spec());
+  if (data.size())
     request_info->peer->OnReceivedCachedMetadata(&data.front(), data.size());
-  }
 }
 
 void ResourceDispatcher::OnReceivedData(const IPC::Message& message,
                                         int request_id,
                                         base::SharedMemoryHandle shm_handle,
                                         int data_len) {
   // Acknowledge the reception of this data.
   message_sender()->Send(
       new ViewHostMsg_DataReceived_ACK(message.routing_id(), request_id));
 
   const bool shm_valid = base::SharedMemory::IsHandleValid(shm_handle);
   DCHECK((shm_valid && data_len > 0) || (!shm_valid && !data_len));
   base::SharedMemory shared_mem(shm_handle, true);  // read only
 
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   if (data_len > 0 && shared_mem.Map(data_len)) {
-    RESOURCE_LOG("Dispatching " << data_len << " bytes for " <<
-        request_info->peer->GetURLForDebugging().possibly_invalid_spec());
     const char* data = static_cast<char*>(shared_mem.memory());
     request_info->peer->OnReceivedData(data, data_len);
   }
 }
 
 void ResourceDispatcher::OnDownloadedData(const IPC::Message& message,
                                           int request_id,
                                           int data_len) {
   // Acknowledge the reception of this message.
   message_sender()->Send(
       new ViewHostMsg_DataDownloaded_ACK(message.routing_id(), request_id));
 
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
-  RESOURCE_LOG("Dispatching " << data_len << " downloaded for " <<
-      request_info->peer->GetURLForDebugging().possibly_invalid_spec());

[darin (slow to review), 2010/10/21 23:31:02]

we can probably delete GetURLForDebugging() now.

   request_info->peer->OnDownloadedData(data_len);
 }
 
 void ResourceDispatcher::OnReceivedRedirect(
     const IPC::Message& message,
     int request_id,
     const GURL& new_url,
     const webkit_glue::ResourceResponseInfo& info) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
-  RESOURCE_LOG(
-      "Dispatching redirect for " <<
-      request_info->peer->GetURLForDebugging().possibly_invalid_spec());
-
   bool has_new_first_party_for_cookies = false;
   GURL new_first_party_for_cookies;
   if (request_info->peer->OnReceivedRedirect(new_url, info,
                                             &has_new_first_party_for_cookies,
                                             &new_first_party_for_cookies)) {
     message_sender()->Send(
         new ViewHostMsg_FollowRedirect(message.routing_id(), request_id,
                                        has_new_first_party_for_cookies,
                                        new_first_party_for_cookies));
   } else {
     CancelPendingRequest(message.routing_id(), request_id);
   }
 }
 
 void ResourceDispatcher::OnRequestComplete(int request_id,
                                            const URLRequestStatus& status,
                                            const std::string& security_info,
                                            const base::Time& completion_time) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   webkit_glue::ResourceLoaderBridge::Peer* peer = request_info->peer;
 
-  RESOURCE_LOG("Dispatching complete for " <<
-               peer->GetURLForDebugging().possibly_invalid_spec());
-
   if (status.status() == URLRequestStatus::CANCELED &&
       status.os_error() != net::ERR_ABORTED) {
     // Resource canceled with a specific error are filtered.
     SecurityFilterPeer* new_peer =
         SecurityFilterPeer::CreateSecurityFilterPeerForDeniedRequest(
             request_info->resource_type,
             request_info->peer,
             status.os_error());
     if (new_peer) {
       request_info->peer = new_peer;
@@ skipping 161 matching lines @@
 
 // static
 void ResourceDispatcher::ReleaseResourcesInMessageQueue(MessageQueue* queue) {
   while (!queue->empty()) {
     IPC::Message* message = queue->front();
     ReleaseResourcesInDataMessage(*message);
     queue->pop_front();
     delete message;
   }
 }