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
122
123
124
125
126
127
128
|
// Copyright 2017 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.
#ifndef COMPONENTS_EXO_DATA_OFFER_H_
#define COMPONENTS_EXO_DATA_OFFER_H_
#include <cstdint>
#include <string>
#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
#include "base/files/scoped_file.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/observer_list.h"
#include "ui/base/class_property.h"
#include "url/gurl.h"
namespace base {
class RefCountedMemory;
}
namespace ui {
class Clipboard;
class OSExchangeData;
}
namespace exo {
class DataOfferDelegate;
class DataOfferObserver;
class FileHelper;
enum class DndAction;
// Object representing transferred data offered to a client.
class DataOffer final : public ui::PropertyHandler {
public:
enum Purpose {
COPY_PASTE,
DRAG_DROP,
};
DataOffer(DataOfferDelegate* delegate, Purpose purpose);
~DataOffer() override;
void AddObserver(DataOfferObserver* observer);
void RemoveObserver(DataOfferObserver* observer);
// Notifies to the DataOffer that the client can accept |mime type|.
void Accept(const std::string* mime_type);
// Notifies to the DataOffer that the client start receiving data of
// |mime_type|. DataOffer writes the request data to |fd|.
void Receive(const std::string& mime_type, base::ScopedFD fd);
// Notifies to the DataOffer that the client no longer uses the DataOffer
// object.
void Finish();
// Notifies to the DataOffer that possible and preferred drag and drop
// operations selected by the client.
void SetActions(const base::flat_set<DndAction>& dnd_actions,
DndAction preferred_action);
// Sets the dropped data from |data| to the DataOffer object. |file_helper|
// will be used to convert paths to handle mount points which is mounted in
// the mount point namespace of clinet process.
// While this function immediately calls DataOfferDelegate::OnOffer inside it
// with found mime types, dropped data bytes may be populated asynchronously
// after this function call.
// (e.g. Asynchronous lookup is required for resolving file system urls.)
void SetDropData(FileHelper* file_helper, const ui::OSExchangeData& data);
// Sets the clipboard data from |data| to the DataOffer object.
void SetClipboardData(FileHelper* file_helper, const ui::Clipboard& data);
// Sets the drag and drop actions which is offered by data source to the
// DataOffer object.
void SetSourceActions(const base::flat_set<DndAction>& source_actions);
DndAction dnd_action() { return dnd_action_; }
private:
void OnPickledUrlsResolved(const std::string& uri_list_mime_type,
const std::vector<GURL>& urls);
DataOfferDelegate* const delegate_;
// Map between mime type and drop data bytes.
// nullptr may be set as a temporary value until data bytes are populated.
base::flat_map<std::string, scoped_refptr<base::RefCountedMemory>> data_;
// Unprocessed receive requests (pairs of mime type and FD) that are waiting
// for unpopulated (nullptr) data bytes in |data_| to be populated.
std::vector<std::pair<std::string, base::ScopedFD>> pending_receive_requests_;
using SendDataCallback = base::RepeatingCallback<void(base::ScopedFD)>;
// Map from mime type (or other offered data type) to a callback that sends
// data for that type. Using callbacks allows us to delay making copies or
// doing other expensive processing until actually necessary.
base::flat_map<std::string, SendDataCallback> data_callbacks_;
base::flat_set<DndAction> source_actions_;
DndAction dnd_action_;
base::ObserverList<DataOfferObserver>::Unchecked observers_;
Purpose purpose_;
base::WeakPtrFactory<DataOffer> weak_ptr_factory_{this};
DISALLOW_COPY_AND_ASSIGN(DataOffer);
};
class ScopedDataOffer {
public:
ScopedDataOffer(DataOffer* data_offer, DataOfferObserver* observer);
~ScopedDataOffer();
DataOffer* get() { return data_offer_; }
private:
DataOffer* const data_offer_;
DataOfferObserver* const observer_;
DISALLOW_COPY_AND_ASSIGN(ScopedDataOffer);
};
} // namespace exo
#endif // COMPONENTS_EXO_DATA_OFFER_H_
|
