String cleanup in sync code

chrome/browser/sync/engine/syncapi.cc

 // Copyright (c) 2006-2009 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/engine/syncapi.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 115 matching lines @@
   }
 
  private:
   AddressWatchTaskParams* const params_;
   DISALLOW_COPY_AND_ASSIGN(AddressWatchTask);
 };
 
 namespace sync_api {
 class ModelSafeWorkerBridge;
 
-static const PSTR_CHAR kBookmarkSyncUserSettingsDatabase[] =
-    PSTR("BookmarkSyncSettings.sqlite3");
+static const FilePath::CharType kBookmarkSyncUserSettingsDatabase[] =
+    FILE_PATH_LITERAL("BookmarkSyncSettings.sqlite3");
 static const PSTR_CHAR kDefaultNameForNewNodes[] = PSTR(" ");
 
 // The list of names which are reserved for use by the server.
 static const char16* kForbiddenServerNames[] =
     { STRING16(""), STRING16("."), STRING16("..") };
 
 //////////////////////////////////////////////////////////////////////////
 // Static helper functions.
 
 // Helper function to look up the int64 metahandle of an object given the ID
@@ skipping 16 matching lines @@
     if (name.compare(0, untrimmed_count, kForbiddenServerNames[i]) == 0)
       return true;
   }
   return false;
 }
 
 static bool EndsWithSpace(const string16& string) {
   return !string.empty() && *string.rbegin() == ' ';
 }
 
-static inline void String16ToPathString(const sync_char16 *in,
-                                        PathString *out) {
-  string16 in_str(in);
-#if defined(OS_WIN)
-  out->assign(in_str);
-#else
-  UTF16ToUTF8(in_str.c_str(), in_str.length(), out);
-#endif
-}
-
-static inline void PathStringToString16(const PathString& in, string16* out) {
-#if defined(OS_WIN)
-  out->assign(in);
-#else
-  UTF8ToUTF16(in.c_str(), in.length(), out);
-#endif
-}
-
 // When taking a name from the syncapi, append a space if it matches the
 // pattern of a server-illegal name followed by zero or more spaces.
 static void SyncAPINameToServerName(const sync_char16 *sync_api_name,
                                     PathString* out) {
-  String16ToPathString(sync_api_name, out);
+  *out = UTF16ToUTF8(sync_api_name);
   string16 sync_api_name_str(sync_api_name);
   if (IsNameServerIllegalAfterTrimming(sync_api_name_str))
     out->append(PSTR(" "));
 }
 
 // In the reverse direction, if a server name matches the pattern of a
 // server-illegal name followed by one or more spaces, remove the trailing
 // space.
 static void ServerNameToSyncAPIName(const PathString& server_name,
                                     string16*out) {
-  string16 server_name_str;
-  PathStringToString16(server_name, &server_name_str);
+  string16 server_name_str(UTF8ToUTF16(server_name));
   if (IsNameServerIllegalAfterTrimming(server_name_str) &&
       EndsWithSpace(server_name_str))
     out->assign(server_name_str, 0, server_name_str.size() - 1);
   else
     out->assign(server_name_str);
 }
 
 // A UserShare encapsulates the syncable pieces that represent an authenticated
 // user and their data (share).
 // This encompasses all pieces required to build transaction objects on the
@@ skipping 46 matching lines @@
 
 const sync_char16* BaseNode::GetTitle() const {
   // Store the string in data_ so that the returned pointer is valid.
   ServerNameToSyncAPIName(GetEntry()->GetName().non_unique_value(),
                          &data_->title);
   return data_->title.c_str();
 }
 
 const sync_char16* BaseNode::GetURL() const {
   // Store the string in data_ so that the returned pointer is valid.
-  PathStringToString16(GetEntry()->Get(syncable::BOOKMARK_URL), &data_->url);
+  data_->url = UTF8ToUTF16(GetEntry()->Get(syncable::BOOKMARK_URL));
   return data_->url.c_str();
 }
 
 const int64* BaseNode::GetChildIds(size_t* child_count) const {
   DCHECK(child_count);
   Directory* dir = GetTransaction()->GetLookup();
   dir->GetChildHandles(GetTransaction()->GetWrappedTrans(),
                        GetEntry()->Get(syncable::ID), &data_->child_handles);
 
   *child_count = data_->child_handles.size();
@@ skipping 64 matching lines @@
   db_name.MakeNoncollidingForEntry(transaction_->GetWrappedTrans(),
                                    entry_->Get(syncable::PARENT_ID), entry_);
 
   syncable::Name new_name = syncable::Name::FromDBNameAndSyncName(db_name,
                                                                   sync_name);
   entry_->PutName(new_name);
   MarkForSyncing();
 }
 
 void WriteNode::SetURL(const sync_char16* url) {
-  PathString url_string;
-  String16ToPathString(url, &url_string);
+  PathString url_string(UTF16ToUTF8(url));
   if (url_string == entry_->Get(syncable::BOOKMARK_URL))
     return;  // Skip redundant changes.
 
   entry_->Put(syncable::BOOKMARK_URL, url_string);
   MarkForSyncing();
 }
 
 void WriteNode::SetExternalId(int64 id) {
   if (GetExternalId() != id)
     entry_->Put(syncable::LOCAL_EXTERNAL_ID, id);
@@ skipping 164 matching lines @@
 const syncable::Entry* ReadNode::GetEntry() const {
   return entry_;
 }
 
 const BaseTransaction* ReadNode::GetTransaction() const {
   return transaction_;
 }
 
 bool ReadNode::InitByTagLookup(const sync_char16* tag) {
   DCHECK(!entry_) << "Init called twice";
-  PathString tag_string;
-  String16ToPathString(tag, &tag_string);
+  PathString tag_string(UTF16ToUTF8(tag));
   if (tag_string.empty())
     return false;
   syncable::BaseTransaction* trans = transaction_->GetWrappedTrans();
   entry_ = new syncable::Entry(trans, syncable::GET_BY_TAG, tag_string);
   if (!entry_->good())
     return false;
   if (entry_->Get(syncable::IS_DEL))
     return false;
   LOG_IF(WARNING, !entry_->Get(syncable::IS_BOOKMARK_OBJECT))
       << "SyncAPI InitByTagLookup referencing non-bookmark object.";
@@ skipping 137 matching lines @@
         command_channel_(0),
         auth_problem_(AUTH_PROBLEM_NONE),
         sync_manager_(sync_manager),
         address_watch_thread_("SyncEngine_AddressWatcher"),
         notification_pending_(false),
         initialized_(false) {
   }
 
   ~SyncInternal() { }
 
-  bool Init(const PathString& database_location,
+  bool Init(const FilePath& database_location,
             const std::string& sync_server_and_path,
             int port,
             const char* gaia_service_id,
             const char* gaia_source,
             bool use_ssl,
             HttpPostProviderFactory* post_factory,
             HttpPostProviderFactory* auth_post_factory,
             ModelSafeWorkerInterface* model_safe_worker,
             bool attempt_last_user_authentication,
             const char* user_agent);
@@ skipping 218 matching lines @@
   // meaning we are ready to accept changes.  Protected by initialized_mutex_
   // as it can get read/set by both the SyncerThread and the AuthWatcherThread.
   bool initialized_;
   mutable Lock initialized_mutex_;
 };
 
 SyncManager::SyncManager() {
   data_ = new SyncInternal(this);
 }
 
-bool SyncManager::Init(const sync_char16* database_location,
+bool SyncManager::Init(const FilePath& database_location,
                        const char* sync_server_and_path,
                        int sync_server_port,
                        const char* gaia_service_id,
                        const char* gaia_source,
                        bool use_ssl,
                        HttpPostProviderFactory* post_factory,
                        HttpPostProviderFactory* auth_post_factory,
                        ModelSafeWorkerInterface* model_safe_worker,
                        bool attempt_last_user_authentication,
                        const char* user_agent) {
-  DCHECK(database_location);
   DCHECK(post_factory);
 
-  PathString db_path;
-  String16ToPathString(database_location, &db_path);
   string server_string(sync_server_and_path);
-  return data_->Init(db_path,
+  return data_->Init(database_location,
                      server_string,
                      sync_server_port,
                      gaia_service_id,
                      gaia_source,
                      use_ssl,
                      post_factory,
                      auth_post_factory,
                      model_safe_worker,
                      attempt_last_user_authentication,
                      user_agent);
 }
 
 void SyncManager::Authenticate(const char* username, const char* password) {
   data_->Authenticate(std::string(username), std::string(password));
 }
 
 const char* SyncManager::GetAuthenticatedUsername() {
   if (!data_)
     return NULL;
   return data_->GetAuthenticatedUsername();
 }
 
 const char* SyncManager::SyncInternal::GetAuthenticatedUsername() {
-  cached_auth_watcher_email_ = browser_sync::ToUTF8(
-      username_for_share()).get_string();
+  cached_auth_watcher_email_ = username_for_share();
   return cached_auth_watcher_email_.c_str();
 }
 
 bool SyncManager::SyncInternal::Init(
-    const PathString& database_location,
+    const FilePath& database_location,
     const std::string& sync_server_and_path,
     int port,
     const char* gaia_service_id,
     const char* gaia_source,
     bool use_ssl, HttpPostProviderFactory* post_factory,
     HttpPostProviderFactory* auth_post_factory,
     ModelSafeWorkerInterface* model_safe_worker,
     bool attempt_last_user_authentication,
     const char* user_agent) {
 
   // Set up UserSettings, creating the db if necessary. We need this to
   // instantiate a URLFactory to give to the Syncer.
-  PathString settings_db_file = AppendSlash(database_location) +
-                                kBookmarkSyncUserSettingsDatabase;
+  FilePath settings_db_file =
+      database_location.Append(FilePath(kBookmarkSyncUserSettingsDatabase));
   user_settings_.reset(new UserSettings());
   if (!user_settings_->Init(settings_db_file))
     return false;
 
   share_.dir_manager.reset(new DirectoryManager(database_location));
 
   string client_id = user_settings_->GetClientId();
   connection_manager_.reset(new SyncAPIServerConnectionManager(
       sync_server_and_path, port, use_ssl, user_agent, client_id));
 
@@ skipping 80 matching lines @@
     initialized_ = true;
   }
 
   // Notify that initialization is complete.
   if (observer_)
     observer_->OnInitializationComplete();
 }
 
 void SyncManager::SyncInternal::Authenticate(const std::string& username,
                                              const std::string& password) {
-  DCHECK(username_for_share().empty() ||
-        (username == browser_sync::ToUTF8(username_for_share()).get_string()))
+  DCHECK(username_for_share().empty() || username == username_for_share())
         << "Username change from valid username detected";
   if (allstatus()->status().authenticated)
     return;
   if (password.empty()) {
     // TODO(timsteele): Seems like this shouldn't be needed, but auth_watcher
     // currently drops blank password attempts on the floor and doesn't update
     // state; it only LOGs an error in this case. We want to make sure we set
     // our AuthProblem state to denote an error.
     RaiseAuthNeededEvent();
   }
   auth_watcher()->Authenticate(username, password, true);
 }
 
 void SyncManager::SyncInternal::AuthenticateForLastKnownUser() {
   std::string username;
   std::string auth_token;
   if (!(auth_watcher()->settings()->GetLastUserAndServiceToken(
         SYNC_SERVICE_NAME, &username, &auth_token))) {
     RaiseAuthNeededEvent();
     return;
   }
 
-  browser_sync::ToPathString s(username);
-  if (s.good()) {
-    share_.authenticated_name = s.get_string16();
-  } else {
-    RaiseAuthNeededEvent();
-    return;
-  }
+  share_.authenticated_name = username;
 
   // We optimize by opening the directory before the "fresh" authentication
   // attempt completes so that we can immediately begin processing changes.
   if (!dir_manager()->Open(username_for_share())) {
     DCHECK(false) << "Had last known user but could not open directory";
     return;
   }
 
   // Set the sync data type so that the server only sends us bookmarks
   // changes.
@@ skipping 295 matching lines @@
   if (event.what_happened == AuthWatcherEvent::AUTHENTICATION_ATTEMPT_START)
     return;
   // We clear our last auth problem cache on new auth watcher events, and only
   // set it to indicate a problem state for certain AuthWatcherEvent types.
   auth_problem_ = AUTH_PROBLEM_NONE;
   switch (event.what_happened) {
     case AuthWatcherEvent::AUTH_SUCCEEDED:
       // We now know the supplied username and password were valid. If this
       // wasn't the first sync, authenticated_name should already be assigned.
       if (username_for_share().empty()) {
-        browser_sync::ToPathString s(event.user_email);
-        if (s.good())
-          share_.authenticated_name = s.get_string16();
+        share_.authenticated_name = event.user_email;
       }
 
-      DCHECK(LowerCaseEqualsASCII(browser_sync::ToUTF8(
-          username_for_share()).get_string(),
+      DCHECK(LowerCaseEqualsASCII(username_for_share(),
           StringToLowerASCII(event.user_email).c_str()))
-          << "username_for_share= "
-          << browser_sync::ToUTF8(username_for_share())
+          << "username_for_share= " << username_for_share()
           << ", event.user_email= " << event.user_email;
 
       if (observer_)
         observer_->OnAuthProblem(AUTH_PROBLEM_NONE);
 
       // Hook up the DirectoryChangeEvent listener, HandleChangeEvent.
       {
         syncable::ScopedDirLookup lookup(dir_manager(), username_for_share());
         if (!lookup.good()) {
           DCHECK(false) << "ScopedDirLookup creation failed; unable to hook "
@@ skipping 57 matching lines @@
   lookup->SaveChanges();
 }
 
 void SyncManager::SetupForTestMode(const sync_char16* test_username) {
   DCHECK(data_) << "SetupForTestMode requires initialization";
   data_->SetupForTestMode(test_username);
 }
 
 void SyncManager::SyncInternal::SetupForTestMode(
     const sync_char16* test_username) {
-  String16ToPathString(test_username, &share_.authenticated_name);
+  share_.authenticated_name = UTF16ToUTF8(test_username);
 
   if (!dir_manager()->Open(username_for_share()))
     DCHECK(false) << "Could not open directory when running in test mode";
 
   // Hook up the DirectoryChangeEvent listener, HandleChangeEvent.
   {
     syncable::ScopedDirLookup lookup(dir_manager(), username_for_share());
     if (!lookup.good()) {
       DCHECK(false) << "ScopedDirLookup creation failed; unable to hook "
                     << "up directory change event listener!";
@@ skipping 19 matching lines @@
 BaseTransaction::~BaseTransaction() {
   delete lookup_;
 }
 
 UserShare* SyncManager::GetUserShare() const {
   DCHECK(data_->initialized()) << "GetUserShare requires initialization!";
   return data_->GetUserShare();
 }
 
 }  // namespace sync_api