--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/platform/gtk/FileSystemGtk.cpp Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,290 @@
+/*
+ * Copyright (C) 2007, 2009 Holger Hans Peter Freyther
+ * Copyright (C) 2008 Collabora, Ltd.
+ * Copyright (C) 2008 Apple Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "FileSystem.h"
+
+#include "GOwnPtr.h"
+#include "PlatformString.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <unistd.h>
+#include <wtf/text/CString.h>
+
+namespace WebCore {
+
+/* On linux file names are just raw bytes, so also strings that cannot be encoded in any way
+ * are valid file names. This mean that we cannot just store a file name as-is in a String
+ * but we have to escape it.
+ * On Windows the GLib file name encoding is always UTF-8 so we can optimize this case. */
+String filenameToString(const char* filename)
+{
+ if (!filename)
+ return String();
+
+#if OS(WINDOWS)
+ return String::fromUTF8(filename);
+#else
+ gchar* escapedString = g_uri_escape_string(filename, "/:", false);
+ String string(escapedString);
+ g_free(escapedString);
+ return string;
+#endif
+}
+
+CString fileSystemRepresentation(const String& path)
+{
+#if OS(WINDOWS)
+ return path.utf8();
+#else
+ char* filename = g_uri_unescape_string(path.utf8().data(), 0);
+ CString cfilename(filename);
+ g_free(filename);
+ return cfilename;
+#endif
+}
+
+// Converts a string to something suitable to be displayed to the user.
+String filenameForDisplay(const String& string)
+{
+#if OS(WINDOWS)
+ return string;
+#else
+ CString filename = fileSystemRepresentation(string);
+ gchar* display = g_filename_to_utf8(filename.data(), 0, 0, 0, 0);
+ if (!display)
+ return string;
+
+ String displayString = String::fromUTF8(display);
+ g_free(display);
+
+ return displayString;
+#endif
+}
+
+bool fileExists(const String& path)
+{
+ bool result = false;
+ CString filename = fileSystemRepresentation(path);
+
+ if (!filename.isNull())
+ result = g_file_test(filename.data(), G_FILE_TEST_EXISTS);
+
+ return result;
+}
+
+bool deleteFile(const String& path)
+{
+ bool result = false;
+ CString filename = fileSystemRepresentation(path);
+
+ if (!filename.isNull())
+ result = g_remove(filename.data()) == 0;
+
+ return result;
+}
+
+bool deleteEmptyDirectory(const String& path)
+{
+ bool result = false;
+ CString filename = fileSystemRepresentation(path);
+
+ if (!filename.isNull())
+ result = g_rmdir(filename.data()) == 0;
+
+ return result;
+}
+
+bool getFileSize(const String& path, long long& resultSize)
+{
+ CString filename = fileSystemRepresentation(path);
+ if (filename.isNull())
+ return false;
+
+ struct stat statResult;
+ gint result = g_stat(filename.data(), &statResult);
+ if (result != 0)
+ return false;
+
+ resultSize = statResult.st_size;
+ return true;
+}
+
+bool getFileModificationTime(const String& path, time_t& modifiedTime)
+{
+ CString filename = fileSystemRepresentation(path);
+ if (filename.isNull())
+ return false;
+
+ struct stat statResult;
+ gint result = g_stat(filename.data(), &statResult);
+ if (result != 0)
+ return false;
+
+ modifiedTime = statResult.st_mtime;
+ return true;
+
+}
+
+String pathByAppendingComponent(const String& path, const String& component)
+{
+ if (path.endsWith(G_DIR_SEPARATOR_S))
+ return path + component;
+ else
+ return path + G_DIR_SEPARATOR_S + component;
+}
+
+bool makeAllDirectories(const String& path)
+{
+ CString filename = fileSystemRepresentation(path);
+ if (filename.isNull())
+ return false;
+
+ gint result = g_mkdir_with_parents(filename.data(), S_IRWXU);
+
+ return result == 0;
+}
+
+String homeDirectoryPath()
+{
+ return filenameToString(g_get_home_dir());
+}
+
+String pathGetFileName(const String& pathName)
+{
+ if (pathName.isEmpty())
+ return pathName;
+
+ CString tmpFilename = fileSystemRepresentation(pathName);
+ char* baseName = g_path_get_basename(tmpFilename.data());
+ String fileName = String::fromUTF8(baseName);
+ g_free(baseName);
+
+ return fileName;
+}
+
+String directoryName(const String& path)
+{
+ /* No null checking needed */
+ GOwnPtr<char> tmpFilename(const_cast<char*>(fileSystemRepresentation(path).data()));
+ GOwnPtr<char> dirname(g_path_get_dirname(tmpFilename.get()));
+ return String::fromUTF8(dirname.get());
+}
+
+Vector<String> listDirectory(const String& path, const String& filter)
+{
+ Vector<String> entries;
+
+ CString filename = fileSystemRepresentation(path);
+ GDir* dir = g_dir_open(filename.data(), 0, 0);
+ if (!dir)
+ return entries;
+
+ GPatternSpec *pspec = g_pattern_spec_new((filter.utf8()).data());
+ while (const char* name = g_dir_read_name(dir)) {
+ if (!g_pattern_match_string(pspec, name))
+ continue;
+
+ GOwnPtr<gchar> entry(g_build_filename(filename.data(), name, NULL));
+ entries.append(filenameToString(entry.get()));
+ }
+ g_pattern_spec_free(pspec);
+ g_dir_close(dir);
+
+ return entries;
+}
+
+CString openTemporaryFile(const char* prefix, PlatformFileHandle& handle)
+{
+ gchar* filename = g_strdup_printf("%sXXXXXX", prefix);
+ gchar* tempPath = g_build_filename(g_get_tmp_dir(), filename, NULL);
+ g_free(filename);
+
+ int fileDescriptor = g_mkstemp(tempPath);
+ if (!isHandleValid(fileDescriptor)) {
+ LOG_ERROR("Can't create a temporary file.");
+ g_free(tempPath);
+ return CString();
+ }
+ CString tempFilePath = tempPath;
+ g_free(tempPath);
+
+ handle = fileDescriptor;
+ return tempFilePath;
+}
+
+PlatformFileHandle openFile(const String& path, FileOpenMode mode)
+{
+ CString fsRep = fileSystemRepresentation(path);
+
+ if (fsRep.isNull())
+ return invalidPlatformFileHandle;
+
+ int platformFlag = 0;
+ if (mode == OpenForRead)
+ platformFlag |= O_RDONLY;
+ else if (mode == OpenForWrite)
+ platformFlag |= (O_WRONLY | O_CREAT | O_TRUNC);
+
+ return g_open(fsRep.data(), platformFlag, 0666);
+}
+
+void closeFile(PlatformFileHandle& handle)
+{
+ if (isHandleValid(handle)) {
+ close(handle);
+ handle = invalidPlatformFileHandle;
+ }
+}
+
+int writeToFile(PlatformFileHandle handle, const char* data, int length)
+{
+ int totalBytesWritten = 0;
+ while (totalBytesWritten < length) {
+ int bytesWritten = write(handle, data, length - totalBytesWritten);
+ if (bytesWritten < 0)
+ return -1;
+ totalBytesWritten += bytesWritten;
+ data += bytesWritten;
+ }
+
+ return totalBytesWritten;
+}
+
+int readFromFile(PlatformFileHandle handle, char* data, int length)
+{
+ do {
+ int bytesRead = read(handle, data, static_cast<size_t>(length));
+ if (bytesRead >= 0)
+ return bytesRead;
+ } while (errno == EINTR);
+
+ return -1;
+}
+
+bool unloadModule(PlatformModule module)
+{
+ return g_module_close(module);
+}
+}