Get rid of FromWStringHack in select_file_dialog.cc

base/values.h

 // 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.
 
 // This file specifies a recursive data storage class called Value intended for
 // storing setting and other persistable data.  It includes the ability to
 // specify (recursive) lists and dictionaries, so it's fairly expressive.
 // However, the API is optimized for the common case, namely storing a
 // hierarchical tree of simple values.  Given a DictionaryValue root, you can
 // easily do things like:
@@ skipping 10 matching lines @@
 #ifndef BASE_VALUES_H_
 #define BASE_VALUES_H_
 #pragma once
 
 #include <iterator>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/file_path.h"
 #include "base/string16.h"
 #include "build/build_config.h"
 
 class Value;
 class FundamentalValue;
 class StringValue;
 class BinaryValue;
 class DictionaryValue;
 class ListValue;
 
 typedef std::vector<Value*> ValueVector;
 typedef std::map<std::string, Value*> ValueMap;
 
 // The Value class is the base class for Values.  A Value can be
 // instantiated via the Create*Value() factory methods, or by directly
 // creating instances of the subclasses.
 class Value {
  public:
   enum ValueType {
     TYPE_NULL = 0,
     TYPE_BOOLEAN,
     TYPE_INTEGER,
     TYPE_REAL,
     TYPE_STRING,
     TYPE_BINARY,
     TYPE_DICTIONARY,
-    TYPE_LIST
+    TYPE_LIST,
+    TYPE_PATH,
   };
 
   virtual ~Value();
 
   // Convenience methods for creating Value objects for various
   // kinds of values without thinking about which class implements them.
   // These can always be expected to return a valid Value*.
   static Value* CreateNullValue();
   static Value* CreateBooleanValue(bool in_value);
   static Value* CreateIntegerValue(int in_value);
@@ skipping 17 matching lines @@
 
   // These methods allow the convenient retrieval of settings.
   // If the current setting object can be converted into the given type,
   // the value is returned through the |out_value| parameter and true is
   // returned;  otherwise, false is returned and |out_value| is unchanged.
   virtual bool GetAsBoolean(bool* out_value) const;
   virtual bool GetAsInteger(int* out_value) const;
   virtual bool GetAsReal(double* out_value) const;
   virtual bool GetAsString(std::string* out_value) const;
   virtual bool GetAsString(string16* out_value) const;
+  virtual bool GetAsFilePath(FilePath* out_value) const;
   virtual bool GetAsList(ListValue** out_value);
 
   // This creates a deep copy of the entire Value tree, and returns a pointer
   // to the copy.  The caller gets ownership of the copy, of course.
   virtual Value* DeepCopy() const;
 
   // Compares if two Value objects have equal contents.
   virtual bool Equals(const Value* other) const;
 
   // Compares if two Value objects have equal contents. Can handle NULLs.
@@ skipping 53 matching lines @@
   virtual bool GetAsString(string16* out_value) const;
   virtual Value* DeepCopy() const;
   virtual bool Equals(const Value* other) const;
 
  private:
   std::string value_;
 
   DISALLOW_COPY_AND_ASSIGN(StringValue);
 };
 
+class FilePathValue : public Value {
+ public:
+  explicit FilePathValue(const FilePath& in_value);
+  virtual ~FilePathValue();
+
+  // Overridden from Value:
+  virtual bool GetAsFilePath(FilePath* out_value) const;
+  virtual bool Equals(const Value* other) const;
+
+ private:
+  FilePath value_;
+
+  DISALLOW_COPY_AND_ASSIGN(FilePathValue);
+};
+
 class BinaryValue: public Value {
  public:
   virtual ~BinaryValue();
 
   // Creates a Value to represent a binary buffer.  The new object takes
   // ownership of the pointer passed in, if successful.
   // Returns NULL if buffer is NULL.
   static BinaryValue* Create(char* buffer, size_t size);
 
   // For situations where you want to keep ownership of your buffer, this
@@ skipping 79 matching lines @@
   bool GetBoolean(const std::string& path, bool* out_value) const;
   bool GetInteger(const std::string& path, int* out_value) const;
   bool GetReal(const std::string& path, double* out_value) const;
   bool GetString(const std::string& path, std::string* out_value) const;
   bool GetString(const std::string& path, string16* out_value) const;
   bool GetStringASCII(const std::string& path, std::string* out_value) const;
   bool GetBinary(const std::string& path, BinaryValue** out_value) const;
   bool GetDictionary(const std::string& path,
                      DictionaryValue** out_value) const;
   bool GetList(const std::string& path, ListValue** out_value) const;
+  bool GetFilePath(const std::string& path, FilePath* out_value) const;
 
   // Like Get(), but without special treatment of '.'.  This allows e.g. URLs to
   // be used as paths.
   bool GetWithoutPathExpansion(const std::string& key,
                                Value** out_value) const;
   bool GetIntegerWithoutPathExpansion(const std::string& key,
                                       int* out_value) const;
   bool GetRealWithoutPathExpansion(const std::string& key,
                                    double* out_value) const;
   bool GetStringWithoutPathExpansion(const std::string& key,
@@ skipping 96 matching lines @@
   // only if the index is valid and the Value at that index can be returned
   // in the specified form.
   bool GetBoolean(size_t index, bool* out_value) const;
   bool GetInteger(size_t index, int* out_value) const;
   bool GetReal(size_t index, double* out_value) const;
   bool GetString(size_t index, std::string* out_value) const;
   bool GetString(size_t index, string16* out_value) const;
   bool GetBinary(size_t index, BinaryValue** out_value) const;
   bool GetDictionary(size_t index, DictionaryValue** out_value) const;
   bool GetList(size_t index, ListValue** out_value) const;
+  bool GetFilePath(size_t index, FilePath* out_value) const;
 
   // Removes the Value with the specified index from this list.
   // If |out_value| is non-NULL, the removed Value AND ITS OWNERSHIP will be
   // passed out via |out_value|.  If |out_value| is NULL, the removed value will
   // be deleted.  This method returns true if |index| is valid; otherwise
   // it will return false and the ListValue object will be unchanged.
   bool Remove(size_t index, Value** out_value);
 
   // Removes the first instance of |value| found in the list, if any, and
   // deletes it.  Returns the index that it was located at (-1 for not present).
@@ skipping 44 matching lines @@
   // This method deserializes the subclass-specific format into a Value object.
   // If the return value is non-NULL, the caller takes ownership of returned
   // Value. If the return value is NULL, and if error_code is non-NULL,
   // error_code will be set with the underlying error.
   // If |error_message| is non-null, it will be filled in with a formatted
   // error message including the location of the error if appropriate.
   virtual Value* Deserialize(int* error_code, std::string* error_str) = 0;
 };
 
 #endif  // BASE_VALUES_H_