Stop using dispatch_set_target_queue()
[WebKit-https.git] / Source / WebKit / NetworkProcess / cache / NetworkCacheIOChannelCocoa.mm
1 /*
2  * Copyright (C) 2014-2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "NetworkCacheIOChannel.h"
28
29 #include "NetworkCacheFileSystem.h"
30 #include <dispatch/dispatch.h>
31 #include <mach/vm_param.h>
32 #include <sys/mman.h>
33 #include <sys/stat.h>
34 #include <wtf/BlockPtr.h>
35 #include <wtf/text/CString.h>
36
37 namespace WebKit {
38 namespace NetworkCache {
39
40 IOChannel::IOChannel(const String& filePath, Type type)
41     : m_path(filePath)
42     , m_type(type)
43 {
44     auto path = WebCore::FileSystem::fileSystemRepresentation(filePath);
45     int oflag;
46     mode_t mode;
47     bool useLowIOPriority = false;
48
49     switch (m_type) {
50     case Type::Create:
51         // We don't want to truncate any existing file (with O_TRUNC) as another thread might be mapping it.
52         unlink(path.data());
53         oflag = O_RDWR | O_CREAT | O_NONBLOCK;
54         mode = S_IRUSR | S_IWUSR;
55         useLowIOPriority = true;
56         break;
57     case Type::Write:
58         oflag = O_WRONLY | O_NONBLOCK;
59         mode = S_IRUSR | S_IWUSR;
60         useLowIOPriority = true;
61         break;
62     case Type::Read:
63         oflag = O_RDONLY | O_NONBLOCK;
64         mode = 0;
65     }
66
67     int fd = ::open(path.data(), oflag, mode);
68     m_fileDescriptor = fd;
69
70     m_dispatchIO = adoptDispatch(dispatch_io_create(DISPATCH_IO_RANDOM, fd, dispatch_get_global_queue(useLowIOPriority ? DISPATCH_QUEUE_PRIORITY_BACKGROUND : DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), [fd](int) {
71         close(fd);
72     }));
73     ASSERT(m_dispatchIO.get());
74
75     // This makes the channel read/write all data before invoking the handlers.
76     dispatch_io_set_low_water(m_dispatchIO.get(), std::numeric_limits<size_t>::max());
77 }
78
79 IOChannel::~IOChannel()
80 {
81     RELEASE_ASSERT(!m_wasDeleted.exchange(true));
82 }
83
84 Ref<IOChannel> IOChannel::open(const String& filePath, IOChannel::Type type)
85 {
86     return adoptRef(*new IOChannel(filePath, type));
87 }
88
89 void IOChannel::read(size_t offset, size_t size, WorkQueue* queue, Function<void (Data&, int error)>&& completionHandler)
90 {
91     RefPtr<IOChannel> channel(this);
92     bool didCallCompletionHandler = false;
93     auto dispatchQueue = queue ? queue->dispatchQueue() : dispatch_get_main_queue();
94     dispatch_io_read(m_dispatchIO.get(), offset, size, dispatchQueue, BlockPtr<void(bool, dispatch_data_t, int)>::fromCallable([channel, completionHandler = WTFMove(completionHandler), didCallCompletionHandler](bool done, dispatch_data_t fileData, int error) mutable {
95         ASSERT_UNUSED(done, done || !didCallCompletionHandler);
96         if (didCallCompletionHandler)
97             return;
98         DispatchPtr<dispatch_data_t> fileDataPtr(fileData);
99         Data data(fileDataPtr);
100         auto callback = WTFMove(completionHandler);
101         callback(data, error);
102         didCallCompletionHandler = true;
103     }).get());
104 }
105
106 void IOChannel::write(size_t offset, const Data& data, WorkQueue* queue, Function<void (int error)>&& completionHandler)
107 {
108     RefPtr<IOChannel> channel(this);
109     auto dispatchData = data.dispatchData();
110     auto dispatchQueue = queue ? queue->dispatchQueue() : dispatch_get_main_queue();
111     dispatch_io_write(m_dispatchIO.get(), offset, dispatchData, dispatchQueue, BlockPtr<void(bool, dispatch_data_t, int)>::fromCallable([channel, completionHandler = WTFMove(completionHandler)](bool done, dispatch_data_t fileData, int error) mutable {
112         ASSERT_UNUSED(done, done);
113         auto callback = WTFMove(completionHandler);
114         callback(error);
115     }).get());
116 }
117
118 }
119 }