1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116
  117
  118
  119
  120
  121


content / public / common / drop_data.cc [blame]

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/public/common/drop_data.h"

#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "net/base/filename_util.h"
#include "net/base/mime_util.h"

namespace content {

// static
DropData::Metadata DropData::Metadata::CreateForMimeType(
    Kind kind,
    const std::u16string& mime_type) {
  Metadata metadata;
  metadata.kind = kind;
  metadata.mime_type = mime_type;
  return metadata;
}

// static
DropData::Metadata DropData::Metadata::CreateForFilePath(
    const base::FilePath& filename) {
  Metadata metadata;
  metadata.kind = Kind::FILENAME;
  metadata.filename = filename;
  return metadata;
}

// static
DropData::Metadata DropData::Metadata::CreateForFileSystemUrl(
    const GURL& file_system_url) {
  Metadata metadata;
  metadata.kind = Kind::FILESYSTEMFILE;
  metadata.file_system_url = file_system_url;
  return metadata;
}

// static
DropData::Metadata DropData::Metadata::CreateForBinary(
    const GURL& file_contents_url) {
  Metadata metadata;
  metadata.kind = Kind::BINARY;
  metadata.file_contents_url = file_contents_url;
  return metadata;
}

DropData::Metadata::Metadata() = default;
DropData::Metadata::Metadata(const DropData::Metadata& other) = default;
DropData::Metadata::~Metadata() = default;

DropData::DropData() = default;
DropData::DropData(const DropData& other) = default;
DropData::~DropData() = default;

std::optional<base::FilePath> DropData::GetSafeFilenameForImageFileContents()
    const {
  base::FilePath file_name = net::GenerateFileName(
      file_contents_source_url, file_contents_content_disposition,
      /*referrer_charset=*/std::string(),
      /*suggested_name=*/std::string(),
      /*mime_type=*/std::string(),
      /*default_name=*/std::string());
  std::string mime_type;
  if (net::GetWellKnownMimeTypeFromExtension(file_contents_filename_extension,
                                             &mime_type) &&
      base::StartsWith(mime_type, "image/",
                       base::CompareCase::INSENSITIVE_ASCII)) {
    return file_name.ReplaceExtension(file_contents_filename_extension);
  }
  return std::nullopt;
}

// static
void DropData::FileSystemFileInfo::WriteFileSystemFilesToPickle(
    const std::vector<FileSystemFileInfo>& file_system_files,
    base::Pickle* pickle) {
  pickle->WriteUInt32(file_system_files.size());
  for (const auto& file_system_file : file_system_files) {
    pickle->WriteString(file_system_file.url.spec());
    pickle->WriteInt64(file_system_file.size);
    pickle->WriteString(file_system_file.filesystem_id);
  }
}

// static
bool DropData::FileSystemFileInfo::ReadFileSystemFilesFromPickle(
    const base::Pickle& pickle,
    std::vector<FileSystemFileInfo>* file_system_files) {
  base::PickleIterator iter(pickle);

  uint32_t num_files = 0;
  if (!iter.ReadUInt32(&num_files))
    return false;
  file_system_files->resize(num_files);

  for (uint32_t i = 0; i < num_files; ++i) {
    std::string url_string;
    int64_t size = 0;
    std::string filesystem_id;
    if (!iter.ReadString(&url_string) || !iter.ReadInt64(&size) ||
        !iter.ReadString(&filesystem_id)) {
      return false;
    }

    GURL url(url_string);
    if (!url.is_valid()) {
      return false;
    }

    (*file_system_files)[i].url = url;
    (*file_system_files)[i].size = size;
    (*file_system_files)[i].filesystem_id = filesystem_id;
  }
  return true;
}

}  // namespace content