Convert LOG(INFO) to VLOG(1) - chrome_frame/.

chrome_frame/urlmon_url_request.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.
 
 #include "chrome_frame/urlmon_url_request.h"
 
 #include <wininet.h>
 #include <urlmon.h>
 
 #include "base/logging.h"
@@ skipping 15 matching lines @@
 UrlmonUrlRequest::UrlmonUrlRequest()
     : pending_read_size_(0),
       headers_received_(false),
       calling_delegate_(0),
       thread_(NULL),
       parent_window_(NULL),
       privileged_mode_(false),
       pending_(false),
       is_expecting_download_(true),
       cleanup_transaction_(false) {
-  DLOG(INFO) << __FUNCTION__ << me();
+  DVLOG(1) << __FUNCTION__ << me();
 }
 
 UrlmonUrlRequest::~UrlmonUrlRequest() {
-  DLOG(INFO) << __FUNCTION__ << me();
+  DVLOG(1) << __FUNCTION__ << me();
 }
 
 std::string UrlmonUrlRequest::me() const {
   return base::StringPrintf(" id: %i Obj: %X ", id(), this);
 }
 
 bool UrlmonUrlRequest::Start() {
-  DLOG(INFO) << __FUNCTION__ << me() << url();
+  DVLOG(1) << __FUNCTION__ << me() << url();
   DCHECK(thread_ == 0 || thread_ == PlatformThread::CurrentId());
   thread_ = PlatformThread::CurrentId();
   status_.Start();
   // The UrlmonUrlRequest instance can get destroyed in the context of
   // StartAsyncDownload if BindToStorage finishes synchronously with an error.
   // Grab a reference to protect against this.
   scoped_refptr<UrlmonUrlRequest> ref(this);
   HRESULT hr = StartAsyncDownload();
   if (FAILED(hr) && status_.get_state() != UrlmonUrlRequest::Status::DONE) {
     status_.Done();
@@ skipping 28 matching lines @@
       status_.Cancel();
       NotifyDelegateAndDie();
       break;
   }
 }
 
 bool UrlmonUrlRequest::Read(int bytes_to_read) {
   DCHECK_EQ(thread_, PlatformThread::CurrentId());
   DCHECK_GE(bytes_to_read, 0);
   DCHECK_EQ(0, calling_delegate_);
-  DLOG(INFO) << __FUNCTION__ << me();
+  DVLOG(1) << __FUNCTION__ << me();
 
   is_expecting_download_ = false;
 
   // Re-entrancy check. Thou shall not call Read() while process OnReadComplete!
   DCHECK_EQ(0u, pending_read_size_);
   if (pending_read_size_ != 0)
     return false;
 
   DCHECK((status_.get_state() != Status::DONE) == (binding_ != NULL));
   if (status_.get_state() == Status::ABORTING)
     return true;
 
   // Send data if available.
   size_t bytes_copied = 0;
   if ((bytes_copied = SendDataToDelegate(bytes_to_read))) {
-    DLOG(INFO) << __FUNCTION__ << me() << " bytes read: " << bytes_copied;
+    DVLOG(1) << __FUNCTION__ << me() << " bytes read: " << bytes_copied;
     return true;
   }
 
   if (status_.get_state() == Status::WORKING) {
-    DLOG(INFO) << __FUNCTION__ << me() << " pending: " << bytes_to_read;
+    DVLOG(1) << __FUNCTION__ << me() << " pending: " << bytes_to_read;
     pending_read_size_ = bytes_to_read;
   } else {
-    DLOG(INFO) << __FUNCTION__ << me() << " Response finished.";
+    DVLOG(1) << __FUNCTION__ << me() << " Response finished.";
     NotifyDelegateAndDie();
   }
 
   return true;
 }
 
 HRESULT UrlmonUrlRequest::InitPending(const GURL& url, IMoniker* moniker,
                                       IBindCtx* bind_context,
                                       bool enable_frame_busting,
                                       bool privileged_mode,
                                       HWND notification_window,
                                       IStream* cache) {
-  DLOG(INFO) << __FUNCTION__ << me() << url.spec();
+  DVLOG(1) << __FUNCTION__ << me() << url.spec();
   DCHECK(bind_context_ == NULL);
   DCHECK(moniker_ == NULL);
   DCHECK(cache_ == NULL);
   DCHECK(thread_ == 0 || thread_ == PlatformThread::CurrentId());
   thread_ = PlatformThread::CurrentId();
   bind_context_ = bind_context;
   moniker_ = moniker;
   enable_frame_busting_ = enable_frame_busting;
   privileged_mode_ = privileged_mode;
   parent_window_ = notification_window;
   cache_ = cache;
   set_url(url.spec());
   set_pending(true);
 
   // Request has already started and data is fetched. We will get the
   // GetBindInfo call as per contract but the return values are
   // ignored. So just set "get" as a method to make our GetBindInfo
   // implementation happy.
   method_ = "get";
   return S_OK;
 }
 
 void UrlmonUrlRequest::TerminateBind(TerminateBindCallback* callback) {
   DCHECK_EQ(thread_, PlatformThread::CurrentId());
-  DLOG(INFO) << __FUNCTION__ << me();
+  DVLOG(1) << __FUNCTION__ << me();
   cleanup_transaction_ = false;
   if (status_.get_state() == Status::DONE) {
     // Binding is stopped. Note result could be an error.
     callback->Run(moniker_, bind_context_);
     delete callback;
   } else {
     // WORKING (ABORTING?). Save the callback.
     // Now we will return INET_TERMINATE_BIND from ::OnDataAvailable() and in
     // ::OnStopBinding will invoke the callback passing our moniker and
     // bind context.
@@ skipping 21 matching lines @@
 size_t UrlmonUrlRequest::SendDataToDelegate(size_t bytes_to_read) {
   DCHECK_EQ(thread_, PlatformThread::CurrentId());
   DCHECK_NE(id(), -1);
   DCHECK_GT(bytes_to_read, 0U);
   size_t bytes_copied = 0;
   if (delegate_) {
     std::string read_data;
     if (cache_) {
       HRESULT hr = ReadStream(cache_, bytes_to_read, &read_data);
       if (hr == S_FALSE || read_data.length() < bytes_to_read) {
-        DLOG(INFO) << __FUNCTION__ << me() << "all cached data read";
+        DVLOG(1) << __FUNCTION__ << me() << "all cached data read";
         cache_.Release();
       }
     }
 
     if (read_data.empty() && pending_data_) {
       size_t pending_data_read_save = pending_read_size_;
       pending_read_size_ = 0;
 
       // AddRef the stream while we call Read to avoid a potential issue
       // where we can get a call to OnDataAvailable while inside Read and
@@ skipping 55 matching lines @@
 
   if (status_.get_state() != Status::WORKING)
     return S_OK;
 
   // Ignore any notifications received while we are in the pending state
   // waiting for the request to be initiated by Chrome.
   if (pending_ && status_code != BINDSTATUS_REDIRECTING)
     return S_OK;
 
   if (!delegate_) {
-    DLOG(INFO) << "Invalid delegate";
+    DVLOG(1) << "Invalid delegate";
     return S_OK;
   }
 
   switch (status_code) {
     case BINDSTATUS_REDIRECTING: {
       // If we receive a redirect for the initial pending request initiated
       // when our document loads we should stash it away and inform Chrome
       // accordingly when it requests data for the original URL.
       ScopedComPtr<BindContextInfo> info;
       BindContextInfo::FromBindContext(bind_context_, info.Receive());
       DCHECK(info);
       GURL previously_redirected(info ? info->url() : std::wstring());
       if (GURL(status_text) != previously_redirected) {
-        DLOG(INFO) << __FUNCTION__ << me() << "redirect from " << url()
-            << " to " << status_text;
+        DVLOG(1) << __FUNCTION__ << me() << "redirect from " << url()
+                 << " to " << status_text;
         // Fetch the redirect status as they aren't all equal (307 in particular
         // retains the HTTP request verb).
         int http_code = GetHttpResponseStatusFromBinding(binding_);
         status_.SetRedirected(http_code, WideToUTF8(status_text));
         // Abort. We will inform Chrome in OnStopBinding callback.
         binding_->Abort();
         return E_ABORT;
       }
       break;
     }
@@ skipping 20 matching lines @@
 
     case BINDSTATUS_COOKIE_STATE_DOWNGRADE:
       delegate_->AddPrivacyDataForUrl(url(), "", COOKIEACTION_DOWNGRADE);
       break;
 
     case BINDSTATUS_COOKIE_STATE_UNKNOWN:
       NOTREACHED() << L"Unknown cookie state received";
       break;
 
     default:
-      DLOG(INFO) << __FUNCTION__ << me()
-          << base::StringPrintf(L"code: %i status: %ls", status_code,
-                                status_text);
+      DVLOG(1) << __FUNCTION__ << me()
+               << base::StringPrintf(L"code: %i status: %ls", status_code,
+                                     status_text);
       break;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnStopBinding(HRESULT result, LPCWSTR error) {
   DCHECK_EQ(thread_, PlatformThread::CurrentId());
-  DLOG(INFO) << __FUNCTION__ << me() <<
-      "- Request stopped, Result: " << std::hex << result;
+  DVLOG(1) << __FUNCTION__ << me()
+           << "- Request stopped, Result: " << std::hex << result;
   DCHECK(status_.get_state() == Status::WORKING ||
          status_.get_state() == Status::ABORTING);
 
   Status::State state = status_.get_state();
 
   // Mark we a are done.
   status_.Done();
 
   if (result == INET_E_TERMINATED_BIND) {
     if (terminate_requested()) {
@@ skipping 104 matching lines @@
     if (resource_type_ != ResourceType::MAIN_FRAME)
       *bind_flags |= BINDF_NOWRITECACHE;
 
     // Initialize the STGMEDIUM.
     memset(&bind_info->stgmedData, 0, sizeof(STGMEDIUM));
     bind_info->grfBindInfoF = 0;
     bind_info->szCustomVerb = NULL;
 
     if (get_upload_data(&bind_info->stgmedData.pstm) == S_OK) {
       bind_info->stgmedData.tymed = TYMED_ISTREAM;
-      DLOG(INFO) << __FUNCTION__ << me() << method()
-                 << " request with " << base::Int64ToString(post_data_len())
-                 << " bytes. url=" << url();
+      DVLOG(1) << __FUNCTION__ << me() << method()
+               << " request with " << base::Int64ToString(post_data_len())
+               << " bytes. url=" << url();
     } else {
-      DLOG(INFO) << __FUNCTION__ << me() << "POST request with no data!";
+      DVLOG(1) << __FUNCTION__ << me() << "POST request with no data!";
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnDataAvailable(DWORD flags, DWORD size,
                                                FORMATETC* formatetc,
                                                STGMEDIUM* storage) {
   DCHECK_EQ(thread_, PlatformThread::CurrentId());
-  DLOG(INFO) << __FUNCTION__ << me() << "bytes available: " << size;
+  DVLOG(1) << __FUNCTION__ << me() << "bytes available: " << size;
 
   if (terminate_requested()) {
-    DLOG(INFO) << " Download requested. INET_E_TERMINATED_BIND returned";
+    DVLOG(1) << " Download requested. INET_E_TERMINATED_BIND returned";
     return INET_E_TERMINATED_BIND;
   }
 
   if (!storage || (storage->tymed != TYMED_ISTREAM)) {
     NOTREACHED();
     return E_INVALIDARG;
   }
 
   IStream* read_stream = storage->pstm;
   if (!read_stream) {
     NOTREACHED();
     return E_UNEXPECTED;
   }
 
   // Some requests such as HEAD have zero data.
   if (size > 0)
     pending_data_ = read_stream;
 
   if (pending_read_size_) {
     size_t bytes_copied = SendDataToDelegate(pending_read_size_);
-    DLOG(INFO) << __FUNCTION__ << me() << "size read: " << bytes_copied;
+    DVLOG(1) << __FUNCTION__ << me() << "size read: " << bytes_copied;
   } else {
-    DLOG(INFO) << __FUNCTION__ << me() << "- waiting for remote read";
+    DVLOG(1) << __FUNCTION__ << me() << "- waiting for remote read";
   }
 
   if (BSCF_LASTDATANOTIFICATION & flags) {
     if (!is_expecting_download_ || pending()) {
-      DLOG(INFO) << __FUNCTION__ << me() << "EOF";
+      DVLOG(1) << __FUNCTION__ << me() << "EOF";
       return S_OK;
     }
     // Always return INET_E_TERMINATED_BIND to allow bind context reuse
     // if DownloadToHost is suddenly requested.
-    DLOG(INFO) << __FUNCTION__ << " EOF: INET_E_TERMINATED_BIND returned";
+    DVLOG(1) << __FUNCTION__ << " EOF: INET_E_TERMINATED_BIND returned";
     return INET_E_TERMINATED_BIND;
   }
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnObjectAvailable(REFIID iid, IUnknown* object) {
   // We are calling BindToStorage on the moniker we should always get called
   // back on OnDataAvailable and should never get OnObjectAvailable
   NOTREACHED();
   return E_NOTIMPL;
 }
 
 STDMETHODIMP UrlmonUrlRequest::BeginningTransaction(const wchar_t* url,
     const wchar_t* current_headers, DWORD reserved,
     wchar_t** additional_headers) {
   DCHECK_EQ(thread_, PlatformThread::CurrentId());
   if (!additional_headers) {
     NOTREACHED();
     return E_POINTER;
   }
 
-  DLOG(INFO) << __FUNCTION__ << me() << "headers: \n" << current_headers;
+  DVLOG(1) << __FUNCTION__ << me() << "headers: \n" << current_headers;
 
   if (status_.get_state() == Status::ABORTING) {
     // At times the BINDSTATUS_REDIRECTING notification which is sent to the
     // IBindStatusCallback interface does not have an accompanying HTTP
     // redirect status code, i.e. the attempt to query the HTTP status code
     // from the binding returns 0, 200, etc which are invalid redirect codes.
     // We don't want urlmon to follow redirects. We return E_ABORT in our
     // IBindStatusCallback::OnProgress function and also abort the binding.
     // However urlmon still tries to establish a transaction with the
     // redirected URL which confuses the web server.
@@ skipping 47 matching lines @@
     }
   }
 
   return hr;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnResponse(DWORD dwResponseCode,
     const wchar_t* response_headers, const wchar_t* request_headers,
     wchar_t** additional_headers) {
   DCHECK_EQ(thread_, PlatformThread::CurrentId());
-  DLOG(INFO) << __FUNCTION__ << me() << "headers: \n" << response_headers;
+  DVLOG(1) << __FUNCTION__ << me() << "headers: \n" << response_headers;
 
   if (!delegate_) {
     DLOG(WARNING) << "Invalid delegate";
     return S_OK;
   }
 
   std::string raw_headers = WideToUTF8(response_headers);
 
   delegate_->AddPrivacyDataForUrl(url(), "", 0);
 
@@ skipping 14 matching lines @@
   // NOTE(slightlyoff): We don't use net::HttpResponseHeaders here because
   //    of lingering ICU/base_noicu issues.
   if (enable_frame_busting_) {
     if (http_utils::HasFrameBustingHeader(raw_headers)) {
       DLOG(ERROR) << "X-Frame-Options header other than ALLOWALL " <<
           "detected, navigation canceled";
       return E_FAIL;
     }
   }
 
-  DLOG(INFO) << __FUNCTION__ << me() << "Calling OnResponseStarted";
+  DVLOG(1) << __FUNCTION__ << me() << "Calling OnResponseStarted";
 
   // Inform the delegate.
   headers_received_ = true;
   DCHECK_NE(id(), -1);
   delegate_->OnResponseStarted(id(),
                     "",                   // mime_type
                     raw_headers.c_str(),  // headers
                     0,                    // size
                     base::Time(),         // last_modified
                     status_.get_redirection().utf8_url,
                     status_.get_redirection().http_code);
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::GetWindow(const GUID& guid_reason,
                                          HWND* parent_window) {
   if (!parent_window)
     return E_INVALIDARG;
 
 #ifndef NDEBUG
   wchar_t guid[40] = {0};
   ::StringFromGUID2(guid_reason, guid, arraysize(guid));
-
-  DLOG(INFO) << __FUNCTION__ << me() << "GetWindow: " <<
-      (guid_reason == IID_IAuthenticate ? L" - IAuthenticate" :
-       (guid_reason == IID_IHttpSecurity ? L"IHttpSecurity" :
-        (guid_reason == IID_IWindowForBindingUI ? L"IWindowForBindingUI" :
-                                                  guid)));
+  const wchar_t* str = guid;
+  if (guid_reason == IID_IAuthenticate)
+    str = L"IAuthenticate";
+  else if (guid_reason == IID_IHttpSecurity)
+    str = L"IHttpSecurity";
+  else if (guid_reason == IID_IWindowForBindingUI)
+    str = L"IWindowForBindingUI";
+  DVLOG(1) << __FUNCTION__ << me() << "GetWindow: " << str;
 #endif
   // We should return a non-NULL HWND as parent. Otherwise no dialog is shown.
   // TODO(iyengar): This hits when running the URL request tests.
   DLOG_IF(WARNING, !::IsWindow(parent_window_))
       << "UrlmonUrlRequest::GetWindow - no window!";
   *parent_window = parent_window_;
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::Authenticate(HWND* parent_window,
@@ skipping 31 matching lines @@
   // Chrome about the result. Ideally Chrome should behave in a manner similar
   // to IE, i.e. display the SSL error interstitial page and if the user
   // decides to proceed anyway we would turn off SSL warnings for that
   // particular navigation and allow IE to download the content.
   // We would need to return the certificate information to Chrome for display
   // purposes. Currently we only return a dummy certificate to Chrome.
   // At this point we decided that it is a lot of work at this point and
   // decided to go with the easier option of implementing the IHttpSecurity
   // interface and replicating the checks performed by Urlmon. This
   // causes Urlmon to display a dialog box on the same lines as IE6.
-  DLOG(INFO) << __FUNCTION__ << me() << "Security problem : " << problem;
+  DVLOG(1) << __FUNCTION__ << me() << "Security problem : " << problem;
 
   // On IE6 the default IBindStatusCallback interface does not implement the
   // IHttpSecurity interface and thus causes IE to put up a certificate error
   // dialog box. We need to emulate this behavior for sites with mismatched
   // certificates to work.
   if (GetIEVersion() == IE_6)
     return S_FALSE;
 
   HRESULT hr = E_ABORT;
 
@@ skipping 12 matching lines @@
 
     default: {
       NOTREACHED() << "Unhandled security problem : " << problem;
       break;
     }
   }
   return hr;
 }
 
 HRESULT UrlmonUrlRequest::StartAsyncDownload() {
-  DLOG(INFO) << __FUNCTION__ << me() << url();
+  DVLOG(1) << __FUNCTION__ << me() << url();
   HRESULT hr = E_FAIL;
   DCHECK((moniker_ && bind_context_) || (!moniker_ && !bind_context_));
 
   if (!moniker_.get()) {
     std::wstring wide_url = UTF8ToWide(url());
     hr = CreateURLMonikerEx(NULL, wide_url.c_str(), moniker_.Receive(),
                             URL_MK_UNIFORM);
     if (FAILED(hr)) {
       NOTREACHED() << "CreateURLMonikerEx failed. Error: " << hr;
       return hr;
@@ skipping 44 matching lines @@
   }
 
   DLOG_IF(ERROR, FAILED(hr)) << me() <<
       base::StringPrintf(L"StartAsyncDownload failed: 0x%08X", hr);
 
   return hr;
 }
 
 void UrlmonUrlRequest::NotifyDelegateAndDie() {
   DCHECK_EQ(thread_, PlatformThread::CurrentId());
-  DLOG(INFO) << __FUNCTION__ << me();
+  DVLOG(1) << __FUNCTION__ << me();
 
   PluginUrlRequestDelegate* delegate = delegate_;
   delegate_ = NULL;
   ReleaseBindings();
   TerminateTransaction();
   if (delegate) {
     URLRequestStatus result = status_.get_result();
     delegate->OnResponseEnd(id(), result);
   } else {
     DLOG(WARNING) << __FUNCTION__ << me() << "no delegate";
@@ skipping 113 matching lines @@
                                   enable_frame_busting_, privileged_mode_,
                                   notification_window_, cache);
     // Start the request
     bool is_started = pending_request_->Start();
     DCHECK(is_started);
   }
 }
 
 void UrlmonUrlRequestManager::StartRequest(int request_id,
     const IPC::AutomationURLRequest& request_info) {
-  DLOG(INFO) << __FUNCTION__ << " id: " << request_id;
+  DVLOG(1) << __FUNCTION__ << " id: " << request_id;
   DCHECK_EQ(0, calling_delegate_);
 
   if (stopping_) {
     DLOG(WARNING) << __FUNCTION__ << " request not started (stopping)";
     return;
   }
 
   DCHECK(request_map_.find(request_id) == request_map_.end());
   DCHECK(GURL(request_info.url).is_valid());
 
   scoped_refptr<UrlmonUrlRequest> new_request;
   bool is_started = false;
   if (pending_request_) {
     DCHECK_EQ(pending_request_->url(), request_info.url);
     new_request.swap(pending_request_);
     is_started = true;
-    DLOG(INFO) << __FUNCTION__ << new_request->me()
-        << "assigned id " << request_id;
+    DVLOG(1) << __FUNCTION__ << new_request->me()
+             << " assigned id " << request_id;
   } else {
     CComObject<UrlmonUrlRequest>* created_request = NULL;
     CComObject<UrlmonUrlRequest>::CreateInstance(&created_request);
     new_request = created_request;
   }
 
   new_request->Initialize(static_cast<PluginUrlRequestDelegate*>(this),
       request_id,
       request_info.url,
       request_info.method,
@@ skipping 13 matching lines @@
   } else {
     // Request is already underway, call OnResponse so that the
     // other side can start reading.
     DCHECK(!new_request->response_headers().empty());
     new_request->OnResponse(
         0, UTF8ToWide(new_request->response_headers()).c_str(), NULL, NULL);
   }
 }
 
 void UrlmonUrlRequestManager::ReadRequest(int request_id, int bytes_to_read) {
-  DLOG(INFO) << __FUNCTION__ << " id: " << request_id;
+  DVLOG(1) << __FUNCTION__ << " id: " << request_id;
   DCHECK_EQ(0, calling_delegate_);
   scoped_refptr<UrlmonUrlRequest> request = LookupRequest(request_id);
   // if zero, it may just have had network error.
   if (request)
     request->Read(bytes_to_read);
 }
 
 void UrlmonUrlRequestManager::DownloadRequestInHost(int request_id) {
-  DLOG(INFO) << __FUNCTION__ << " " << request_id;
+  DVLOG(1) << __FUNCTION__ << " " << request_id;
   if (IsWindow(notification_window_)) {
     scoped_refptr<UrlmonUrlRequest> request(LookupRequest(request_id));
     if (request) {
       UrlmonUrlRequest::TerminateBindCallback* callback = NewCallback(this,
           &UrlmonUrlRequestManager::BindTerminated);
       request->TerminateBind(callback);
     } else {
       NOTREACHED();
     }
   } else {
-    NOTREACHED()
-        << "Cannot handle download if we don't have anyone to hand it to.";
+    NOTREACHED() << "Cannot handle download if we don't have anyone to hand it "
+                    "to.";
   }
 }
 
 void UrlmonUrlRequestManager::BindTerminated(IMoniker* moniker,
                                              IBindCtx* bind_ctx) {
   // We use SendMessage and not PostMessage to make sure that if the
   // notification window does not handle the message we won't leak
   // the moniker.
   ::SendMessage(notification_window_, WM_DOWNLOAD_IN_HOST,
         reinterpret_cast<WPARAM>(bind_ctx),
@@ skipping 16 matching lines @@
                             &cookie_size)) {
       success = false;
       error = GetLastError();
       NOTREACHED() << "InternetGetCookie failed. Error: " << error;
     } else {
       cookie_string = cookies.get();
     }
   } else {
     success = false;
     error = GetLastError();
-    DLOG(INFO) << "InternetGetCookie failed. Error: " << error;
+    DVLOG(1) << "InternetGetCookie failed. Error: " << error;
   }
 
   OnCookiesRetrieved(success, url, cookie_string, cookie_id);
   if (!success && !error)
     cookie_action = COOKIEACTION_SUPPRESS;
 
   AddPrivacyDataForUrl(url.spec(), "", cookie_action);
 }
 
 void UrlmonUrlRequestManager::SetCookiesForUrl(const GURL& url,
@@ skipping 12 matching lines @@
 
   int32 cookie_action = MapCookieStateToCookieAction(cookie_state);
   AddPrivacyDataForUrl(url.spec(), "", cookie_action);
 
   if (container_) {
     container_->Release();
   }
 }
 
 void UrlmonUrlRequestManager::EndRequest(int request_id) {
-  DLOG(INFO) << __FUNCTION__ << " id: " << request_id;
+  DVLOG(1) << __FUNCTION__ << " id: " << request_id;
   DCHECK_EQ(0, calling_delegate_);
   scoped_refptr<UrlmonUrlRequest> request = LookupRequest(request_id);
   if (request) {
     request_map_.erase(request_id);
     request->Stop();
   } else {
     DLOG(ERROR) << __FUNCTION__ << " no request found for " << request_id;
   }
 }
 
 void UrlmonUrlRequestManager::StopAll() {
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   if (stopping_)
     return;
 
   stopping_ = true;
 
-  DLOG(INFO) << __FUNCTION__ << " stopping " <<
-      request_map_.size() << " requests";
+  DVLOG(1) << __FUNCTION__ << " stopping " << request_map_.size()
+           << " requests";
 
   for (RequestMap::iterator it = request_map_.begin();
        it != request_map_.end(); ++it) {
     DCHECK(it->second != NULL);
     it->second->Stop();
   }
 
   request_map_.empty();
 }
 
 void UrlmonUrlRequestManager::OnResponseStarted(int request_id,
     const char* mime_type, const char* headers, int size,
     base::Time last_modified, const std::string& redirect_url,
     int redirect_status) {
   DCHECK_NE(request_id, -1);
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   DCHECK(LookupRequest(request_id) != NULL);
   ++calling_delegate_;
   delegate_->OnResponseStarted(request_id, mime_type, headers, size,
       last_modified, redirect_url, redirect_status);
   --calling_delegate_;
 }
 
 void UrlmonUrlRequestManager::OnReadComplete(int request_id,
                                              const std::string& data) {
   DCHECK_NE(request_id, -1);
-  DLOG(INFO) << __FUNCTION__ << " id: " << request_id;
+  DVLOG(1) << __FUNCTION__ << " id: " << request_id;
   DCHECK(LookupRequest(request_id) != NULL);
   ++calling_delegate_;
   delegate_->OnReadComplete(request_id, data);
   --calling_delegate_;
-  DLOG(INFO) << __FUNCTION__ << " done id: " << request_id;
+  DVLOG(1) << __FUNCTION__ << " done id: " << request_id;
 }
 
 void UrlmonUrlRequestManager::OnResponseEnd(int request_id,
                                             const URLRequestStatus& status) {
   DCHECK_NE(request_id, -1);
-  DLOG(INFO) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__;
   DCHECK(status.status() != URLRequestStatus::CANCELED);
   RequestMap::size_type n = request_map_.erase(request_id);
   DCHECK_EQ(1u, n);
   ++calling_delegate_;
   delegate_->OnResponseEnd(request_id, status);
   --calling_delegate_;
 }
 
 void UrlmonUrlRequestManager::OnCookiesRetrieved(bool success, const GURL& url,
     const std::string& cookie_string, int cookie_id) {
@@ skipping 42 matching lines @@
       privacy_info_.privacy_records[UTF8ToWide(url)];
 
   privacy_entry.flags |= flags;
   privacy_entry.policy_ref = UTF8ToWide(policy_ref);
 
   if (fire_privacy_event && IsWindow(notification_window_)) {
     PostMessage(notification_window_, WM_FIRE_PRIVACY_CHANGE_NOTIFICATION, 1,
                 0);
   }
 }