more changes

chrome/browser/sync/sync_ui_util.cc

 // Copyright (c) 2011 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/sync/sync_ui_util.h"
 
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/time_formatting.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 331 matching lines @@
   } else {
     sync_api::SyncManager::Status full_status(
         service->QueryDetailedSyncStatus());
 
     strings->SetString("service_url", service->sync_service_url().spec());
     strings->SetString("summary",
                        ProfileSyncService::BuildSyncStatusSummaryText(
                        full_status.summary));
 
     strings->Set("authenticated",
-                 new base::FundamentalValue(full_status.authenticated));
+                 base::BooleanValue::New(full_status.authenticated));
     strings->SetString("auth_problem",
                        sync_ui_util::MakeSyncAuthErrorText(
                        service->GetAuthError().state()));
 
     strings->SetString("time_since_sync", service->GetLastSyncedTimeString());
 
     ListValue* details = new ListValue();
     strings->Set("details", details);
     sync_ui_util::AddBoolSyncDetail(details, "Sync Initialized",
                                     service->sync_initialized());
@@ skipping 98 matching lines @@
       // unsynced  However if we query the latest count here we will
       // have to hold the transaction which means we cannot display this page
       // when syncing.
       sync_ui_util::AddIntSyncDetail(details, "Entries" ,
                                      snapshot->num_entries);
       sync_ui_util::AddBoolSyncDetail(details, "Throttled",
                                       snapshot->is_silenced);
     }
 
     if (service->unrecoverable_error_detected()) {
-      strings->Set("unrecoverable_error_detected",
-                   new base::FundamentalValue(true));
+      strings->Set("unrecoverable_error_detected", base::TrueValue());
       tracked_objects::Location loc(service->unrecoverable_error_location());
       std::string location_str;
       loc.Write(true, true, &location_str);
       std::string unrecoverable_error_message =
           "Unrecoverable error detected at " + location_str +
           ": " + service->unrecoverable_error_message();
       strings->SetString("unrecoverable_error_message",
                          unrecoverable_error_message);
     } else if (service->sync_initialized()) {
       browser_sync::ModelSafeRoutingInfo routes;
       service->GetModelSafeRoutingInfo(&routes);
       ListValue* routing_info = new ListValue();
       strings->Set("routing_info", routing_info);
       browser_sync::ModelSafeRoutingInfo::const_iterator it = routes.begin();
       for (; it != routes.end(); ++it) {
         DictionaryValue* val = new DictionaryValue;
         val->SetString("model_type", ModelTypeToString(it->first));
         val->SetString("group", ModelSafeGroupToString(it->second));
         routing_info->Append(val);
       }
     }
   }
 }
 
 }  // namespace sync_ui_util