Port some files in chrome/common to Linux....

chrome/common/pref_service.cc

 // Copyright (c) 2006-2008 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/common/pref_service.h"
 
+#include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/thread.h"
 #include "chrome/common/json_value_serializer.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/stl_util-inl.h"
@@ skipping 16 matching lines @@
         data_(data) {
   }
 
   void Run() {
     // Write the data to a temp file then rename to avoid data loss if we crash
     // while writing the file.
     std::wstring tmp_file_name = file_name_ + L".tmp";
     int bytes_written = file_util::WriteFile(tmp_file_name, data_.c_str(),
                                              static_cast<int>(data_.length()));
     if (bytes_written != -1) {
-      if (!MoveFileEx(tmp_file_name.c_str(), file_name_.c_str(),
-                      MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING)) {
+      if (!file_util::Move(tmp_file_name, file_name_)) {
         // Rename failed. Try again on the off chance someone has locked either
         // file and hope we're successful the second time through.
-        BOOL move_result =
-            MoveFileEx(tmp_file_name.c_str(), file_name_.c_str(),
-                       MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING);
+        bool move_result = file_util::Move(tmp_file_name, file_name_);
         DCHECK(move_result);
       }
     }
   }
 
  private:
   std::wstring file_name_;
   std::string data_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(SaveLaterTask);
+  DISALLOW_COPY_AND_ASSIGN(SaveLaterTask);
 };
 
 // A helper function for RegisterLocalized*Pref that creates a Value* based on
 // the string value in the locale dll.  Because we control the values in a
 // locale dll, this should always return a Value of the appropriate type.
 Value* CreateLocaleDefaultValue(Value::ValueType type, int message_id) {
   std::wstring resource_string = l10n_util::GetString(message_id);
   DCHECK(!resource_string.empty());
   switch (type) {
     case Value::TYPE_BOOLEAN: {
       if (L"true" == resource_string)
         return Value::CreateBooleanValue(true);
       if (L"false" == resource_string)
         return Value::CreateBooleanValue(false);
       break;
     }
 
     case Value::TYPE_INTEGER: {
-      int num_int = 0;
-      int parsed_values = swscanf_s(resource_string.c_str(), L"%d", &num_int);
-      // This is a trusted value (comes from our locale dll), so it should
-      // successfully parse.
-      DCHECK(parsed_values == 1);
-      return Value::CreateIntegerValue(num_int);
+      return Value::CreateIntegerValue(StringToInt(resource_string));
       break;
     }
 
     case Value::TYPE_REAL: {
-      double num_double = 0.0;
-      int parsed_values = swscanf_s(resource_string.c_str(), L"%lf",
-                                    &num_double);
-      // This is a trusted value (comes from our locale dll), so it should
-      // successfully parse.
-      DCHECK(parsed_values == 1);
-      return Value::CreateRealValue(num_double);
+      return Value::CreateRealValue(StringToDouble(resource_string));
       break;
     }
 
     case Value::TYPE_STRING: {
       return Value::CreateStringValue(resource_string);
       break;
     }
 
     default: {
       DCHECK(false) <<
           "list and dictionary types can not have default locale values";
     }
   }
   NOTREACHED();
   return Value::CreateNullValue();
 }
 
 }  // namespace
 
 PrefService::PrefService()
     : persistent_(new DictionaryValue),
       transient_(new DictionaryValue),
       save_preferences_factory_(NULL) {
 }
 
 PrefService::PrefService(const std::wstring& pref_filename)
     : persistent_(new DictionaryValue),
       transient_(new DictionaryValue),
       pref_filename_(pref_filename),
-#pragma warning(suppress: 4355)  // Okay to pass "this" here.
-      save_preferences_factory_(this) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(save_preferences_factory_(this)) {
   LoadPersistentPrefs(pref_filename_);
 }
 
 PrefService::~PrefService() {
   DCHECK(CalledOnValidThread());
 
   // Verify that there are no pref observers when we shut down.
   for (PrefObserverMap::iterator it = pref_observers_.begin();
        it != pref_observers_.end(); ++it) {
     NotificationObserverList::Iterator obs_iterator(*(it->second));
@@ skipping 291 matching lines @@
   if (observer_iterator == pref_observers_.end()) {
     observer_list = new NotificationObserverList;
     pref_observers_[path] = observer_list;
   } else {
     observer_list = observer_iterator->second;
   }
 
   // Verify that this observer doesn't already exist.
   NotificationObserverList::Iterator it(*observer_list);
   NotificationObserver* existing_obs;
-  while (existing_obs = it.GetNext()) {
+  while ((existing_obs = it.GetNext()) != NULL) {
     DCHECK(existing_obs != obs) << path << " observer already registered";
     if (existing_obs == obs)
       return;
   }
 
   // Ok, safe to add the pref observer.
   observer_list->AddObserver(obs);
 }
 
 void PrefService::RemovePrefObserver(const wchar_t* path,
@@ skipping 185 matching lines @@
 
   // Convert path to a std::wstring because the Details constructor requires a
   // class.
   std::wstring path_str(path);
   PrefObserverMap::iterator observer_iterator = pref_observers_.find(path_str);
   if (observer_iterator == pref_observers_.end())
     return;
 
   NotificationObserverList::Iterator it(*(observer_iterator->second));
   NotificationObserver* observer;
-  while (observer = it.GetNext()) {
+  while ((observer = it.GetNext()) != NULL) {
     observer->Observe(NOTIFY_PREF_CHANGED,
                       Source<PrefService>(this),
                       Details<std::wstring>(&path_str));
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // PrefService::Preference
 
 PrefService::Preference::Preference(DictionaryValue* root_pref,
                                     const wchar_t* name,
                                     Value* default_value)
-      : root_pref_(root_pref),
+      : type_(Value::TYPE_NULL),
         name_(name),
         default_value_(default_value),
-        type_(Value::TYPE_NULL) {
+        root_pref_(root_pref) {
   DCHECK(name);
 
   if (default_value) {
     type_ = default_value->GetType();
     DCHECK(type_ != Value::TYPE_NULL && type_ != Value::TYPE_BINARY) <<
         "invalid preference type: " << type_;
   }
 
   // We set the default value of lists and dictionaries to be null so it's
   // easier for callers to check for empty list/dict prefs.
@@ skipping 13 matching lines @@
 
   // Pref not found, just return the app default.
   return default_value_.get();
 }
 
 bool PrefService::Preference::IsDefaultValue() const {
   DCHECK(default_value_.get());
   return default_value_->Equals(GetValue());
 }