Return a FilePath from Settings::file_path()

client/settings.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 39 matching lines @@
       initialized_() {
 }
 
 Settings::~Settings() {
 }
 
 bool Settings::Initialize() {
   INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
 
   ScopedFileHandle handle(HANDLE_EINTR(
-      open(file_path(),
+      open(file_path().value().c_str(),
            O_CREAT | O_EXCL | O_WRONLY | O_EXLOCK,
            0644)));
 
   // The file was created, so this is a new database that needs to be
   // initialized with a client ID.
   if (handle.is_valid()) {
     bool initialized = InitializeSettings(handle.get());
     if (initialized)
       INITIALIZATION_STATE_SET_VALID(initialized_);
     return initialized;
@@ skipping 67 matching lines @@
   ScopedFileHandle handle = OpenForWritingAndReadSettings(&settings);
   if (!handle.is_valid())
     return false;
 
   settings.last_upload_attempt_time = InRangeCast<uint64_t>(time, 0);
 
   return WriteSettings(handle.get(), settings);
 }
 
 ScopedFileHandle Settings::OpenForReading() {
-  ScopedFileHandle handle(HANDLE_EINTR(open(file_path(), O_RDONLY | O_SHLOCK)));
+  ScopedFileHandle handle(HANDLE_EINTR(
+      open(file_path().value().c_str(), O_RDONLY | O_SHLOCK)));
   PLOG_IF(ERROR, !handle.is_valid()) << "open for reading";
   return handle.Pass();
 }
 
 ScopedFileHandle Settings::OpenForReadingAndWriting() {
   ScopedFileHandle handle(HANDLE_EINTR(
-      open(file_path(), O_RDWR | O_EXLOCK | O_CREAT, 0644)));
+      open(file_path().value().c_str(), O_RDWR | O_EXLOCK | O_CREAT, 0644)));
   PLOG_IF(ERROR, !handle.is_valid()) << "open for writing";
   return handle.Pass();
 }
 
 bool Settings::OpenAndReadSettings(Data* out_data) {
   ScopedFileHandle handle = OpenForReading();
   if (!handle.is_valid())
     return false;
 
   if (ReadSettings(handle.get(), out_data))
@@ skipping 51 matching lines @@
   if (handle == kInvalidFileHandle) {
     scoped_handle.reset(OpenForReadingAndWriting().release());
     handle = scoped_handle.get();
 
     // Test if the file has already been recovered now that the exclusive lock
     // is held.
     if (ReadSettings(handle, out_data))
       return true;
   }
 
-  LOG(INFO) << "Recovering settings file " << file_path();
+  LOG(INFO) << "Recovering settings file " << file_path().value();
 
   if (handle == kInvalidFileHandle) {
     LOG(ERROR) << "Invalid file handle";
     return false;
   }
 
   if (!InitializeSettings(handle))
     return false;
 
   return ReadSettings(handle, out_data);
 }
 
 bool Settings::InitializeSettings(FileHandle handle) {
   uuid_t uuid;
   uuid_generate(uuid);
 
   Data settings;
   settings.client_id.InitializeFromBytes(uuid);
 
   return WriteSettings(handle, settings);
 }
 
 }  // namespace crashpad