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

chrome_frame/protocol_sink_wrap.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 <htiframe.h>
 #include <mshtml.h>
 
 #include "chrome_frame/protocol_sink_wrap.h"
 
 #include "base/logging.h"
@@ skipping 68 matching lines @@
 END_VTABLE_PATCHES()
 
 //
 // ProtocolSinkWrap implementation
 
 // Static map initialization
 ProtData::ProtocolDataMap ProtData::datamap_;
 Lock ProtData::datamap_lock_;
 
 ProtocolSinkWrap::ProtocolSinkWrap() {
-  DLOG(INFO) << __FUNCTION__ << base::StringPrintf(" 0x%08X", this);
+  DVLOG(1) << __FUNCTION__ << base::StringPrintf(" 0x%08X", this);
 }
 
 ProtocolSinkWrap::~ProtocolSinkWrap() {
-  DLOG(INFO) << __FUNCTION__ << base::StringPrintf(" 0x%08X", this);
+  DVLOG(1) << __FUNCTION__ << base::StringPrintf(" 0x%08X", this);
 }
 
 ScopedComPtr<IInternetProtocolSink> ProtocolSinkWrap::CreateNewSink(
     IInternetProtocolSink* sink, ProtData* data) {
   DCHECK(sink != NULL);
   DCHECK(data != NULL);
   CComObject<ProtocolSinkWrap>* new_sink = NULL;
   CComObject<ProtocolSinkWrap>::CreateInstance(&new_sink);
   new_sink->delegate_ = sink;
   new_sink->prot_data_ = data;
@@ skipping 45 matching lines @@
 // IInternetProtocolSink methods
 STDMETHODIMP ProtocolSinkWrap::Switch(PROTOCOLDATA* protocol_data) {
   HRESULT hr = E_FAIL;
   if (delegate_)
     hr = delegate_->Switch(protocol_data);
   return hr;
 }
 
 STDMETHODIMP ProtocolSinkWrap::ReportProgress(ULONG status_code,
                                               LPCWSTR status_text) {
-  DLOG(INFO) << "ProtocolSinkWrap::ReportProgress: "
-      <<  BindStatus2Str(status_code)
-      << " Status: " << (status_text ? status_text : L"");
+  DVLOG(1) << "ProtocolSinkWrap::ReportProgress: "
+           << BindStatus2Str(status_code)
+           << " Status: " << (status_text ? status_text : L"");
 
   HRESULT hr = prot_data_->ReportProgress(delegate_, status_code, status_text);
   return hr;
 }
 
 STDMETHODIMP ProtocolSinkWrap::ReportData(DWORD flags, ULONG progress,
     ULONG max_progress) {
   DCHECK(delegate_);
-  DLOG(INFO) << "ProtocolSinkWrap::ReportData: " << Bscf2Str(flags) <<
-      " progress: " << progress << " progress_max: " << max_progress;
+  DVLOG(1) << "ProtocolSinkWrap::ReportData: " << Bscf2Str(flags)
+           << " progress: " << progress << " progress_max: " << max_progress;
 
   HRESULT hr = prot_data_->ReportData(delegate_, flags, progress, max_progress);
   return hr;
 }
 
 STDMETHODIMP ProtocolSinkWrap::ReportResult(HRESULT result, DWORD error,
     LPCWSTR result_text) {
-  DLOG(INFO) << "ProtocolSinkWrap::ReportResult: result: " << result <<
-      " error: " << error << " Text: " << (result_text ? result_text : L"");
+  DVLOG(1) << "ProtocolSinkWrap::ReportResult: result: " << result
+           << " error: " << error
+           << " Text: " << (result_text ? result_text : L"");
   ExceptionBarrier barrier;
   HRESULT hr = prot_data_->ReportResult(delegate_, result, error, result_text);
   return hr;
 }
 
 
 // Helpers
 ScopedComPtr<IBindCtx> BindCtxFromIBindInfo(IInternetBindInfo* bind_info) {
   LPOLESTR bind_ctx_string = NULL;
   ULONG count;
@@ skipping 162 matching lines @@
 }
 
 // ProtData
 ProtData::ProtData(IInternetProtocol* protocol,
                    InternetProtocol_Read_Fn read_fun, const wchar_t* url)
     : has_suggested_mime_type_(false), has_server_mime_type_(false),
       buffer_size_(0), buffer_pos_(0),
       renderer_type_(RENDERER_TYPE_UNDETERMINED), protocol_(protocol),
       read_fun_(read_fun), url_(url) {
   memset(buffer_, 0, arraysize(buffer_));
-  DLOG(INFO) << __FUNCTION__ << " " << this;
+  DVLOG(1) << __FUNCTION__ << " " << this;
 
   // Add to map.
   AutoLock lock(datamap_lock_);
   DCHECK(datamap_.end() == datamap_.find(protocol_));
   datamap_[protocol] = this;
 }
 
 ProtData::~ProtData() {
-  DLOG(INFO) << __FUNCTION__ << " " << this;
+  DVLOG(1) << __FUNCTION__ << " " << this;
   Invalidate();
 }
 
 HRESULT ProtData::Read(void* buffer, ULONG size, ULONG* size_read) {
   if (renderer_type_ == RENDERER_TYPE_UNDETERMINED) {
     return E_PENDING;
   }
 
   const ULONG bytes_available = buffer_size_ - buffer_pos_;
   const ULONG bytes_to_copy = std::min(bytes_available, size);
@@ skipping 69 matching lines @@
         // We may ask CTransaction (our protocol_ member) for IWinInetHttpInfo.
         ScopedComPtr<IWinInetHttpInfo> info;
         info.QueryFrom(delegate);
         renderer_type_ = DetermineRendererTypeFromMetaData(suggested_mime_type_,
                                                            url_, info);
       }
 
       if (IsChrome(renderer_type_)) {
         // Suggested mime type is "text/html" and we have DEFAULT_RENDERER,
         // OPT_IN_URL, or RESPONSE_HEADER.
-        DLOG(INFO) << "Forwarding BINDSTATUS_MIMETYPEAVAILABLE "
-                   << kChromeMimeType;
+        DVLOG(1) << "Forwarding BINDSTATUS_MIMETYPEAVAILABLE "
+                 << kChromeMimeType;
         SaveReferrer(delegate);
         delegate->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, kChromeMimeType);
       } else if (renderer_type_ == RENDERER_TYPE_OTHER) {
         // Suggested mime type is not "text/html" - we are not interested in
         // this request anymore.
         FireSuggestedMimeType(delegate);
       } else {
         // Suggested mime type is "text/html"; We will try to sniff the
         // HTML content in ReportData.
         DCHECK_EQ(RENDERER_TYPE_UNDETERMINED, renderer_type_);
@@ skipping 22 matching lines @@
   }
 
   renderer_type_ = DetermineRendererType(buffer_, buffer_size_, last_chance);
 
   if (renderer_type_ == RENDERER_TYPE_UNDETERMINED) {
     // do not report anything, we need more data.
     return S_OK;
   }
 
   if (IsChrome(renderer_type_)) {
-    DLOG(INFO) << "Forwarding BINDSTATUS_MIMETYPEAVAILABLE "
-        << kChromeMimeType;
+    DVLOG(1) << "Forwarding BINDSTATUS_MIMETYPEAVAILABLE " << kChromeMimeType;
     SaveReferrer(delegate);
     delegate->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, kChromeMimeType);
   }
 
   if (renderer_type_ == RENDERER_TYPE_OTHER) {
     FireSuggestedMimeType(delegate);
   }
 
   // This is the first data notification we forward, since up to now we hold
   // the content received.
   flags |= BSCF_FIRSTDATANOTIFICATION;
 
   if (hr == S_FALSE) {
     flags |= (BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE);
   }
 
   return delegate->ReportData(flags, progress, max_progress);
 }
 
 HRESULT ProtData::ReportResult(IInternetProtocolSink* delegate, HRESULT result,
                                DWORD error, LPCWSTR result_text) {
   // We may receive ReportResult without ReportData, if the connection fails
   // for example.
   if (renderer_type_ == RENDERER_TYPE_UNDETERMINED) {
-    DLOG(INFO) << "ReportResult received but renderer type is yet unknown.";
+    DVLOG(1) << "ReportResult received but renderer type is yet unknown.";
     renderer_type_ = RENDERER_TYPE_OTHER;
     FireSuggestedMimeType(delegate);
   }
 
   HRESULT hr = S_OK;
   if (delegate)
     hr = delegate->ReportResult(result, error, result_text);
   return hr;
 }
 
@@ skipping 19 matching lines @@
   return hr_read;
 }
 
 void ProtData::SaveSuggestedMimeType(LPCWSTR status_text) {
   has_suggested_mime_type_ = true;
   suggested_mime_type_.Allocate(status_text);
 }
 
 void ProtData::FireSuggestedMimeType(IInternetProtocolSink* delegate) {
   if (has_server_mime_type_) {
-    DLOG(INFO) << "Forwarding BINDSTATUS_SERVER_MIMETYPEAVAILABLE "
-        << suggested_mime_type_;
+    DVLOG(1) << "Forwarding BINDSTATUS_SERVER_MIMETYPEAVAILABLE "
+             << suggested_mime_type_;
     delegate->ReportProgress(BINDSTATUS_SERVER_MIMETYPEAVAILABLE,
                              suggested_mime_type_);
   }
 
   if (has_suggested_mime_type_) {
-    DLOG(INFO) << "Forwarding BINDSTATUS_MIMETYPEAVAILABLE "
-        << suggested_mime_type_;
+    DVLOG(1) << "Forwarding BINDSTATUS_MIMETYPEAVAILABLE "
+             << suggested_mime_type_;
     delegate->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE,
                              suggested_mime_type_);
   }
 }
 
 void ProtData::SaveReferrer(IInternetProtocolSink* delegate) {
   DCHECK(IsChrome(renderer_type_));
   ScopedComPtr<IWinInetHttpInfo> info;
   info.QueryFrom(delegate);
   if (info) {
@@ skipping 83 matching lines @@
     IInternetBindInfo* bind_info, DWORD flags, HANDLE_PTR reserved) {
   DCHECK(orig_start);
   if (!url || !prot_sink || !bind_info)
     return E_INVALIDARG;
   DLOG_IF(INFO, url != NULL) << "OnStart: " << url << PiFlags2Str(flags);
 
   ScopedComPtr<IBindCtx> bind_ctx = BindCtxFromIBindInfo(bind_info);
   if (!bind_ctx) {
     // MSHTML sometimes takes a short path, skips the creation of
     // moniker and binding, by directly grabbing protocol from InternetSession
-    DLOG(INFO) << "DirectBind for " << url;
+    DVLOG(1) << "DirectBind for " << url;
     return ForwardHookStart(orig_start, protocol, url, prot_sink, bind_info,
                             flags, reserved);
   }
 
   scoped_refptr<ProtData> prot_data = ProtData::DataFromProtocol(protocol);
   if (prot_data && !HasProtData(bind_ctx)) {
     prot_data->Invalidate();
     prot_data = NULL;
   }
 
   if (HandleAttachToExistingExternalTab(url, protocol, prot_sink, bind_ctx)) {
     return S_OK;
   }
 
   if (IsCFRequest(bind_ctx)) {
     return ForwardHookStart(orig_start, protocol, url, prot_sink, bind_info,
                             flags, reserved);
   }
 
   if (prot_data) {
-    DLOG(INFO) << "Found existing ProtData!";
+    DVLOG(1) << "Found existing ProtData!";
     prot_data->UpdateUrl(url);
     ScopedComPtr<IInternetProtocolSink> new_sink =
         ProtocolSinkWrap::CreateNewSink(prot_sink, prot_data);
     return ForwardWrappedHookStart(orig_start, protocol, url, new_sink,
                                    bind_info, flags, reserved);
   }
 
   if (!ShouldWrapSink(prot_sink, url)) {
     return ForwardHookStart(orig_start, protocol, url, prot_sink, bind_info,
                             flags, reserved);
@@ skipping 33 matching lines @@
     return E_INVALIDARG;
 
   ScopedBstr url;
   uri->GetPropertyBSTR(Uri_PROPERTY_ABSOLUTE_URI, url.Receive(), 0);
   DLOG_IF(INFO, url != NULL) << "OnStartEx: " << url << PiFlags2Str(flags);
 
   ScopedComPtr<IBindCtx> bind_ctx = BindCtxFromIBindInfo(bind_info);
   if (!bind_ctx) {
     // MSHTML sometimes takes a short path, skips the creation of
     // moniker and binding, by directly grabbing protocol from InternetSession.
-    DLOG(INFO) << "DirectBind for " << url;
+    DVLOG(1) << "DirectBind for " << url;
     return ForwardHookStartEx(orig_start_ex, protocol, uri, prot_sink,
                               bind_info, flags, reserved);
   }
 
   scoped_refptr<ProtData> prot_data = ProtData::DataFromProtocol(protocol);
   if (prot_data && !HasProtData(bind_ctx)) {
     prot_data->Invalidate();
     prot_data = NULL;
   }
 
   if (HandleAttachToExistingExternalTab(url, protocol, prot_sink, bind_ctx)) {
     return S_OK;
   }
 
   if (IsCFRequest(bind_ctx)) {
     return ForwardHookStartEx(orig_start_ex, protocol, uri, prot_sink,
                               bind_info, flags, reserved);
   }
 
   if (prot_data) {
-    DLOG(INFO) << "Found existing ProtData!";
+    DVLOG(1) << "Found existing ProtData!";
     prot_data->UpdateUrl(url);
     ScopedComPtr<IInternetProtocolSink> new_sink =
         ProtocolSinkWrap::CreateNewSink(prot_sink, prot_data);
     return ForwardWrappedHookStartEx(orig_start_ex, protocol, uri, new_sink,
                                      bind_info, flags, reserved);
   }
 
   if (!ShouldWrapSink(prot_sink, url)) {
     return ForwardHookStartEx(orig_start_ex, protocol, uri, prot_sink,
                               bind_info, flags, reserved);
@@ skipping 163 matching lines @@
     // Explicit release, otherwise ~CComObjectStackEx will complain about
     // outstanding reference to us, because it runs before ~FakeProtocol
     prot.transaction_.Release();
   }
 }
 
 void TransactionHooks::RevertHooks() {
   vtable_patch::UnpatchInterfaceMethods(CTransaction_PatchInfo);
   vtable_patch::UnpatchInterfaceMethods(CTransaction2_PatchInfo);
 }