[chrome/browser/s*] Convert VLOGs to DVLOGs

chrome/browser/signin/android_profile_oauth2_token_service.cc

 // Copyright 2013 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/browser/signin/android_profile_oauth2_token_service.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
@@ skipping 116 matching lines @@
     scope += *it;
   }
   return scope;
 }
 
 }  // namespace
 
 bool AndroidProfileOAuth2TokenService::is_testing_profile_ = false;
 
 AndroidProfileOAuth2TokenService::AndroidProfileOAuth2TokenService() {
-  VLOG(1) << "AndroidProfileOAuth2TokenService::ctor";
+  DVLOG(1) << "AndroidProfileOAuth2TokenService::ctor";
   JNIEnv* env = AttachCurrentThread();
   base::android::ScopedJavaLocalRef<jobject> local_java_ref =
       Java_OAuth2TokenService_create(env, reinterpret_cast<intptr_t>(this));
   java_ref_.Reset(env, local_java_ref.obj());
 }
 
 AndroidProfileOAuth2TokenService::~AndroidProfileOAuth2TokenService() {}
 
 // static
 jobject AndroidProfileOAuth2TokenService::GetForProfile(
     JNIEnv* env, jclass clazz, jobject j_profile_android) {
   Profile* profile = ProfileAndroid::FromProfileAndroid(j_profile_android);
   AndroidProfileOAuth2TokenService* service =
       ProfileOAuth2TokenServiceFactory::GetPlatformSpecificForProfile(profile);
   return service->java_ref_.obj();
 }
 
 static jobject GetForProfile(JNIEnv* env,
                              jclass clazz,
                              jobject j_profile_android) {
   return AndroidProfileOAuth2TokenService::GetForProfile(
       env, clazz, j_profile_android);
 }
 
 void AndroidProfileOAuth2TokenService::Initialize(SigninClient* client) {
-  VLOG(1) << "AndroidProfileOAuth2TokenService::Initialize";
+  DVLOG(1) << "AndroidProfileOAuth2TokenService::Initialize";
   ProfileOAuth2TokenService::Initialize(client);
 
   if (!is_testing_profile_) {
     Java_OAuth2TokenService_validateAccounts(
         AttachCurrentThread(), java_ref_.obj(),
         base::android::GetApplicationContext(), JNI_TRUE);
   }
 }
 
 bool AndroidProfileOAuth2TokenService::RefreshTokenIsAvailable(
@@ skipping 65 matching lines @@
   Java_OAuth2TokenService_invalidateOAuth2AuthToken(
       env, base::android::GetApplicationContext(),
       j_access_token.obj());
 }
 
 void AndroidProfileOAuth2TokenService::ValidateAccounts(
     JNIEnv* env,
     jobject obj,
     jstring j_current_acc,
     jboolean j_force_notifications) {
-  VLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts from java";
+  DVLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts from java";
   std::string signed_in_account = ConvertJavaStringToUTF8(env, j_current_acc);
   if (!signed_in_account.empty())
     signed_in_account = gaia::CanonicalizeEmail(signed_in_account);
   ValidateAccounts(signed_in_account, j_force_notifications != JNI_FALSE);
 }
 
 void AndroidProfileOAuth2TokenService::ValidateAccounts(
     const std::string& signed_in_account,
     bool force_notifications) {
   std::vector<std::string> prev_ids = GetAccounts();
   std::vector<std::string> curr_ids = GetSystemAccounts();
   std::vector<std::string> refreshed_ids;
   std::vector<std::string> revoked_ids;
 
   // Canonicalize system accounts.  |prev_ids| is already done.
   for (size_t i = 0; i < curr_ids.size(); ++i)
     curr_ids[i] = gaia::CanonicalizeEmail(curr_ids[i]);
   for (size_t i = 0; i < prev_ids.size(); ++i)
     ValidateAccountId(prev_ids[i]);
 
-  VLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts:"
-          << " sigined_in_account=" << signed_in_account
-          << " prev_ids=" << prev_ids.size()
-          << " curr_ids=" << curr_ids.size()
-          << " force=" << (force_notifications ? "true" : "false");
+  DVLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts:"
+           << " sigined_in_account=" << signed_in_account
+           << " prev_ids=" << prev_ids.size()
+           << " curr_ids=" << curr_ids.size()
+           << " force=" << (force_notifications ? "true" : "false");
 
   if (!ValidateAccounts(signed_in_account, prev_ids, curr_ids, refreshed_ids,
                         revoked_ids, force_notifications)) {
     curr_ids.clear();
   }
 
   ScopedBatchChange batch(this);
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobjectArray> java_accounts(
@@ skipping 25 matching lines @@
     // Test to see if an account is removed from the Android AccountManager.
     // If so, invoke FireRefreshTokenRevoked to notify the reconcilor.
     for (std::vector<std::string>::const_iterator it = prev_account_ids.begin();
          it != prev_account_ids.end(); it++) {
       if (*it == signed_in_account)
         continue;
 
       if (std::find(curr_account_ids.begin(),
                     curr_account_ids.end(),
                     *it) == curr_account_ids.end()) {
-        VLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts:"
-                << "revoked=" << *it;
+        DVLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts:"
+                 << "revoked=" << *it;
         revoked_ids.push_back(*it);
       }
     }
 
     if (force_notifications ||
         std::find(prev_account_ids.begin(), prev_account_ids.end(),
                   signed_in_account) == prev_account_ids.end()) {
       // Always fire the primary signed in account first.
-      VLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts:"
-              << "refreshed=" << signed_in_account;
+      DVLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts:"
+               << "refreshed=" << signed_in_account;
       refreshed_ids.push_back(signed_in_account);
     }
 
     for (std::vector<std::string>::const_iterator it = curr_account_ids.begin();
          it != curr_account_ids.end(); it++) {
       if (*it != signed_in_account) {
         if (force_notifications ||
             std::find(prev_account_ids.begin(),
                       prev_account_ids.end(),
                       *it) == prev_account_ids.end()) {
-          VLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts:"
-                  << "refreshed=" << *it;
+          DVLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts:"
+                   << "refreshed=" << *it;
           refreshed_ids.push_back(*it);
         }
       }
     }
     return true;
   } else {
     // Currently signed in account does not any longer exist among accounts on
     // system together with all other accounts.
     if (std::find(prev_account_ids.begin(), prev_account_ids.end(),
                   signed_in_account) != prev_account_ids.end()) {
-      VLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts:"
-              << "revoked=" << signed_in_account;
+      DVLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts:"
+               << "revoked=" << signed_in_account;
       revoked_ids.push_back(signed_in_account);
     }
     for (std::vector<std::string>::const_iterator it = prev_account_ids.begin();
          it != prev_account_ids.end(); it++) {
       if (*it == signed_in_account)
         continue;
-      VLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts:"
-              << "revoked=" << *it;
+      DVLOG(1) << "AndroidProfileOAuth2TokenService::ValidateAccounts:"
+               << "revoked=" << *it;
       revoked_ids.push_back(*it);
     }
     return false;
   }
 }
 
 void AndroidProfileOAuth2TokenService::FireRefreshTokenAvailableFromJava(
     JNIEnv* env,
     jobject obj,
     const jstring account_name) {
   std::string account_id = ConvertJavaStringToUTF8(env, account_name);
   AndroidProfileOAuth2TokenService::FireRefreshTokenAvailable(account_id);
 }
 
 void AndroidProfileOAuth2TokenService::FireRefreshTokenAvailable(
     const std::string& account_id) {
-  VLOG(1) << "AndroidProfileOAuth2TokenService::FireRefreshTokenAvailable id="
-          << account_id;
+  DVLOG(1) << "AndroidProfileOAuth2TokenService::FireRefreshTokenAvailable id="
+           << account_id;
 
   // Notify native observers.
   OAuth2TokenService::FireRefreshTokenAvailable(account_id);
   // Notify Java observers.
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> account_name =
       ConvertUTF8ToJavaString(env, account_id);
   Java_OAuth2TokenService_notifyRefreshTokenAvailable(
       env, java_ref_.obj(), account_name.obj());
 }
 
 void AndroidProfileOAuth2TokenService::FireRefreshTokenRevokedFromJava(
     JNIEnv* env,
     jobject obj,
     const jstring account_name) {
   std::string account_id = ConvertJavaStringToUTF8(env, account_name);
   AndroidProfileOAuth2TokenService::FireRefreshTokenRevoked(account_id);
 }
 
 void AndroidProfileOAuth2TokenService::FireRefreshTokenRevoked(
     const std::string& account_id) {
-  VLOG(1) << "AndroidProfileOAuth2TokenService::FireRefreshTokenRevoked id="
-          << account_id;
+  DVLOG(1) << "AndroidProfileOAuth2TokenService::FireRefreshTokenRevoked id="
+           << account_id;
 
   // Notify native observers.
   OAuth2TokenService::FireRefreshTokenRevoked(account_id);
   // Notify Java observers.
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> account_name =
       ConvertUTF8ToJavaString(env, account_id);
   Java_OAuth2TokenService_notifyRefreshTokenRevoked(
       env, java_ref_.obj(), account_name.obj());
 }
 
 void AndroidProfileOAuth2TokenService::FireRefreshTokensLoadedFromJava(
     JNIEnv* env,
     jobject obj) {
   AndroidProfileOAuth2TokenService::FireRefreshTokensLoaded();
 }
 
 void AndroidProfileOAuth2TokenService::FireRefreshTokensLoaded() {
-  VLOG(1) << "AndroidProfileOAuth2TokenService::FireRefreshTokensLoaded";
+  DVLOG(1) << "AndroidProfileOAuth2TokenService::FireRefreshTokensLoaded";
   // Notify native observers.
   OAuth2TokenService::FireRefreshTokensLoaded();
   // Notify Java observers.
   JNIEnv* env = AttachCurrentThread();
   Java_OAuth2TokenService_notifyRefreshTokensLoaded(
       env, java_ref_.obj());
 }
 
 void AndroidProfileOAuth2TokenService::RevokeAllCredentials() {
-  VLOG(1) << "AndroidProfileOAuth2TokenService::RevokeAllCredentials";
+  DVLOG(1) << "AndroidProfileOAuth2TokenService::RevokeAllCredentials";
   ScopedBatchChange batch(this);
   std::vector<std::string> accounts = GetAccounts();
   for (std::vector<std::string>::iterator it = accounts.begin();
        it != accounts.end(); it++) {
     FireRefreshTokenRevoked(*it);
   }
 
   // Clear everything on the Java side as well.
   std::vector<std::string> empty;
   JNIEnv* env = AttachCurrentThread();
@@ skipping 19 matching lines @@
   GoogleServiceAuthError err(result ?
                              GoogleServiceAuthError::NONE :
                              GoogleServiceAuthError::CONNECTION_FAILED);
   heap_callback->Run(err, token, base::Time());
 }
 
 // static
 bool AndroidProfileOAuth2TokenService::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }