Move PathExists to base namespace.

base/prefs/json_pref_store.cc

 // Copyright (c) 2012 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 "base/prefs/json_pref_store.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 51 matching lines @@
   }
 
   static base::Value* DoReading(const base::FilePath& path,
                                 PersistentPrefStore::PrefReadError* error,
                                 bool* no_dir) {
     int error_code;
     std::string error_msg;
     JSONFileValueSerializer serializer(path);
     base::Value* value = serializer.Deserialize(&error_code, &error_msg);
     HandleErrors(value, path, error_code, error_msg, error);
-    *no_dir = !file_util::PathExists(path.DirName());
+    *no_dir = !base::PathExists(path.DirName());
     return value;
   }
 
   static void HandleErrors(const base::Value* value,
                            const base::FilePath& path,
                            int error_code,
                            const std::string& error_msg,
                            PersistentPrefStore::PrefReadError* error);
 
  private:
@@ skipping 38 matching lines @@
         // Since the file is corrupt, move it to the side and continue with
         // empty preferences.  This will result in them losing their settings.
         // We keep the old file for possible support and debugging assistance
         // as well as to detect if they're seeing these errors repeatedly.
         // TODO(erikkay) Instead, use the last known good file.
         base::FilePath bad = path.ReplaceExtension(kBadExtension);
 
         // If they've ever had a parse error before, put them in another bucket.
         // TODO(erikkay) if we keep this error checking for very long, we may
         // want to differentiate between recent and long ago errors.
-        if (file_util::PathExists(bad))
+        if (base::PathExists(bad))
           *error = PersistentPrefStore::PREF_READ_ERROR_JSON_REPEAT;
         base::Move(path, bad);
         break;
     }
   } else if (!value->IsType(base::Value::TYPE_DICTIONARY)) {
     *error = PersistentPrefStore::PREF_READ_ERROR_JSON_TYPE;
   }
 }
 
 }  // namespace
@@ skipping 207 matching lines @@
         copy->Set(key, new base::ListValue);
     } else if (value->IsType(base::Value::TYPE_DICTIONARY)) {
       const base::DictionaryValue* dict = NULL;
       if (value->GetAsDictionary(&dict) && dict->empty())
         copy->Set(key, new base::DictionaryValue);
     }
   }
 
   return serializer.Serialize(*(copy.get()));
 }