Everywhere: Convert ByteBuffer factory methods from Optional -> ErrorOr

Apologies for the enormous commit, but I don't see a way to split this
up nicely. In the vast majority of cases it's a simple change. A few
extra places can use TRY instead of manual error checking though. :^)

Userland/Libraries/LibCore/IODevice.cpp

@@ -49,7 +49,7 @@ ByteBuffer IODevice::read(size_t max_size)
 
     auto size = min(max_size, m_buffered_data.size());
     auto buffer_result = ByteBuffer::create_uninitialized(size);
-    if (!buffer_result.has_value()) {
+    if (buffer_result.is_error()) {
         dbgln("IODevice::read: Not enough memory to allocate a buffer of {} bytes", size);
         return {};
     }
@@ -149,7 +149,7 @@ ByteBuffer IODevice::read_all()
     }
 
     auto result = ByteBuffer::copy(data);
-    if (result.has_value())
+    if (!result.is_error())
         return result.release_value();
 
     set_error(ENOMEM);
@@ -174,7 +174,7 @@ String IODevice::read_line(size_t max_size)
         return line;
     }
     auto line_result = ByteBuffer::create_uninitialized(max_size + 1);
-    if (!line_result.has_value()) {
+    if (line_result.is_error()) {
         dbgln("IODevice::read_line: Not enough memory to allocate a buffer of {} bytes", max_size + 1);
         return {};
     }
@@ -202,7 +202,7 @@ bool IODevice::populate_read_buffer(size_t size) const
         return false;
 
     auto buffer_result = ByteBuffer::create_uninitialized(size);
-    if (!buffer_result.has_value()) {
+    if (buffer_result.is_error()) {
         dbgln("IODevice::populate_read_buffer: Not enough memory to allocate a buffer of {} bytes", size);
         return {};
     }

Userland/Libraries/LibCore/InputBitStream.h

@@ -99,13 +99,9 @@ public:
                         m_current_byte.clear();
                 }
             } else {
-                // FIXME: This returns Optional so TRY is not useable
-                auto temp_buffer = ByteBuffer::create_uninitialized(1);
-                if (!temp_buffer.has_value())
-                    return Error::from_string_literal("Couldn't allocate temporary byte buffer"sv);
-
-                TRY(m_stream.read(temp_buffer->bytes()));
-                m_current_byte = (*temp_buffer)[0];
+                auto temp_buffer = TRY(ByteBuffer::create_uninitialized(1));
+                TRY(m_stream.read(temp_buffer.bytes()));
+                m_current_byte = temp_buffer[0];
                 m_bit_offset = 0;
             }
         }

Userland/Libraries/LibCore/SecretString.cpp

@@ -12,14 +12,13 @@ namespace Core {
 
 SecretString SecretString::take_ownership(char*& cstring, size_t length)
 {
-    auto buffer = ByteBuffer::copy(cstring, length);
-    VERIFY(buffer.has_value());
+    auto buffer = ByteBuffer::copy(cstring, length).release_value_but_fixme_should_propagate_errors();
 
     secure_zero(cstring, length);
     free(cstring);
     cstring = nullptr;
 
-    return SecretString(buffer.release_value());
+    return SecretString(move(buffer));
 }
 
 SecretString SecretString::take_ownership(ByteBuffer&& buffer)

Userland/Libraries/LibCore/Stream.h

@@ -479,11 +479,9 @@ public:
         if (!stream->is_open())
             return Error::from_errno(ENOTCONN);
 
-        auto maybe_buffer = ByteBuffer::create_uninitialized(buffer_size);
-        if (!maybe_buffer.has_value())
-            return Error::from_errno(ENOMEM);
+        auto buffer = TRY(ByteBuffer::create_uninitialized(buffer_size));
 
-        return adopt_nonnull_own_or_enomem(new BufferedType<T>(move(stream), maybe_buffer.release_value()));
+        return adopt_nonnull_own_or_enomem(new BufferedType<T>(move(stream), move(buffer)));
     }
 
     T& stream() { return *m_stream; }

Userland/Libraries/LibCore/UDPServer.cpp

@@ -64,7 +64,7 @@ bool UDPServer::bind(const IPv4Address& address, u16 port)
 ByteBuffer UDPServer::receive(size_t size, sockaddr_in& in)
 {
     // FIXME: Handle possible OOM situation.
-    auto buf = ByteBuffer::create_uninitialized(size).release_value();
+    auto buf = ByteBuffer::create_uninitialized(size).release_value_but_fixme_should_propagate_errors();
     socklen_t in_len = sizeof(in);
     ssize_t rlen = ::recvfrom(m_fd, buf.data(), size, 0, (sockaddr*)&in, &in_len);
     if (rlen < 0) {