Bug 1344038 - Move the gio protocol handler under netwerk/protocol. r=chmanchester,karlt
Historically, we had support for some GNOME VFS protocols through the
gnomevfs library, and this was under extension. This may not have been
built by default when it was introduced, but GNOME upstream moved those
things into Gtk itself, and we then got support for the new Gio-based
protocol, similar to what we had through the gnomevfs library.
Time passes, and we switched off the gnomevfs library entirely, and
enabled the Gio-based protocol handlers by default. We then removed
everything related to the gnomevfs library.
Fast forward to now, and disabling Gio support in Firefox just doesn't
make sense, and leaving the gio protocol handler as an extension doesn't
make sense either.
As it is a protocol handler, its natural place is under
netwerk/protocol, which is where we're moving it here.
The netwerk/protocol subdirectories being handled automatically, we
don't need to add the moved directory in any DIRS variable.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- *//* vim: set ts=8 sts=2 et sw=2 tw=80: *//* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. *//* A class for optional values and in-place lazy construction. */#ifndef mozilla_Maybe_h#define mozilla_Maybe_h#include"mozilla/Alignment.h"#include"mozilla/Assertions.h"#include"mozilla/Attributes.h"#include"mozilla/Move.h"#include"mozilla/OperatorNewExtensions.h"#include"mozilla/TypeTraits.h"#include<new> // for placement new#include<ostream>#include<type_traits>namespacemozilla{structNothing{};/* * Maybe is a container class which contains either zero or one elements. It * serves two roles. It can represent values which are *semantically* optional, * augmenting a type with an explicit 'Nothing' value. In this role, it provides * methods that make it easy to work with values that may be missing, along with * equality and comparison operators so that Maybe values can be stored in * containers. Maybe values can be constructed conveniently in expressions using * type inference, as follows: * * void doSomething(Maybe<Foo> aFoo) { * if (aFoo) // Make sure that aFoo contains a value... * aFoo->takeAction(); // and then use |aFoo->| to access it. * } // |*aFoo| also works! * * doSomething(Nothing()); // Passes a Maybe<Foo> containing no value. * doSomething(Some(Foo(100))); // Passes a Maybe<Foo> containing |Foo(100)|. * * You'll note that it's important to check whether a Maybe contains a value * before using it, using conversion to bool, |isSome()|, or |isNothing()|. You * can avoid these checks, and sometimes write more readable code, using * |valueOr()|, |ptrOr()|, and |refOr()|, which allow you to retrieve the value * in the Maybe and provide a default for the 'Nothing' case. You can also use * |apply()| to call a function only if the Maybe holds a value, and |map()| to * transform the value in the Maybe, returning another Maybe with a possibly * different type. * * Maybe's other role is to support lazily constructing objects without using * dynamic storage. A Maybe directly contains storage for a value, but it's * empty by default. |emplace()|, as mentioned above, can be used to construct a * value in Maybe's storage. The value a Maybe contains can be destroyed by * calling |reset()|; this will happen automatically if a Maybe is destroyed * while holding a value. * * It's a common idiom in C++ to use a pointer as a 'Maybe' type, with a null * value meaning 'Nothing' and any other value meaning 'Some'. You can convert * from such a pointer to a Maybe value using 'ToMaybe()'. * * Maybe is inspired by similar types in the standard library of many other * languages (e.g. Haskell's Maybe and Rust's Option). In the C++ world it's * very similar to std::optional, which was proposed for C++14 and originated in * Boost. The most important differences between Maybe and std::optional are: * * - std::optional<T> may be compared with T. We deliberately forbid that. * - std::optional allows in-place construction without a separate call to * |emplace()| by using a dummy |in_place_t| value to tag the appropriate * constructor. * - std::optional has |valueOr()|, equivalent to Maybe's |valueOr()|, but * lacks corresponding methods for |refOr()| and |ptrOr()|. * - std::optional lacks |map()| and |apply()|, making it less suitable for * functional-style code. * - std::optional lacks many convenience functions that Maybe has. Most * unfortunately, it lacks equivalents of the type-inferred constructor * functions |Some()| and |Nothing()|. * * N.B. GCC has missed optimizations with Maybe in the past and may generate * extra branches/loads/stores. Use with caution on hot paths; it's not known * whether or not this is still a problem. */template<classT>classMOZ_NON_PARAMMaybe{alignas(T)unsignedcharmStorage[sizeof(T)];charmIsSome;// not bool -- guarantees minimal space consumption// GCC fails due to -Werror=strict-aliasing if |mStorage| is directly cast to// T*. Indirecting through these functions addresses the problem.void*data(){returnmStorage;}constvoid*data()const{returnmStorage;}public:usingValueType=T;Maybe():mIsSome(false){}~Maybe(){reset();}MOZ_IMPLICITMaybe(Nothing):mIsSome(false){}Maybe(constMaybe&aOther):mIsSome(false){if(aOther.mIsSome){emplace(*aOther);}}/** * Maybe<T> can be copy-constructed from a Maybe<U> if U is convertible to T. */template<typenameU,typename=typenamestd::enable_if<std::is_convertible<U,T>::value>::type>MOZ_IMPLICITMaybe(constMaybe<U>&aOther):mIsSome(false){if(aOther.isSome()){emplace(*aOther);}}Maybe(Maybe&&aOther):mIsSome(false){if(aOther.mIsSome){emplace(Move(*aOther));aOther.reset();}}/** * Maybe<T> can be move-constructed from a Maybe<U> if U is convertible to T. */template<typenameU,typename=typenamestd::enable_if<std::is_convertible<U,T>::value>::type>MOZ_IMPLICITMaybe(Maybe<U>&&aOther):mIsSome(false){if(aOther.isSome()){emplace(Move(*aOther));aOther.reset();}}Maybe&operator=(constMaybe&aOther){if(&aOther!=this){if(aOther.mIsSome){if(mIsSome){ref()=aOther.ref();}else{emplace(*aOther);}}else{reset();}}return*this;}template<typenameU,typename=typenamestd::enable_if<std::is_convertible<U,T>::value>::type>Maybe&operator=(constMaybe<U>&aOther){if(aOther.isSome()){if(mIsSome){ref()=aOther.ref();}else{emplace(*aOther);}}else{reset();}return*this;}Maybe&operator=(Maybe&&aOther){MOZ_ASSERT(this!=&aOther,"Self-moves are prohibited");if(aOther.mIsSome){if(mIsSome){ref()=Move(aOther.ref());}else{emplace(Move(*aOther));}aOther.reset();}else{reset();}return*this;}template<typenameU,typename=typenamestd::enable_if<std::is_convertible<U,T>::value>::type>Maybe&operator=(Maybe<U>&&aOther){if(aOther.isSome()){if(mIsSome){ref()=Move(aOther.ref());}else{emplace(Move(*aOther));}aOther.reset();}else{reset();}return*this;}/* Methods that check whether this Maybe contains a value */explicitoperatorbool()const{returnisSome();}boolisSome()const{returnmIsSome;}boolisNothing()const{return!mIsSome;}/* Returns the contents of this Maybe<T> by value. Unsafe unless |isSome()|. */Tvalue()const{MOZ_ASSERT(mIsSome);returnref();}/* * Returns the contents of this Maybe<T> by value. If |isNothing()|, returns * the default value provided. */template<typenameV>TvalueOr(V&&aDefault)const{if(isSome()){returnref();}returnForward<V>(aDefault);}/* * Returns the contents of this Maybe<T> by value. If |isNothing()|, returns * the value returned from the function or functor provided. */template<typenameF>TvalueOrFrom(F&&aFunc)const{if(isSome()){returnref();}returnaFunc();}/* Returns the contents of this Maybe<T> by pointer. Unsafe unless |isSome()|. */T*ptr(){MOZ_ASSERT(mIsSome);return&ref();}constT*ptr()const{MOZ_ASSERT(mIsSome);return&ref();}/* * Returns the contents of this Maybe<T> by pointer. If |isNothing()|, * returns the default value provided. */T*ptrOr(T*aDefault){if(isSome()){returnptr();}returnaDefault;}constT*ptrOr(constT*aDefault)const{if(isSome()){returnptr();}returnaDefault;}/* * Returns the contents of this Maybe<T> by pointer. If |isNothing()|, * returns the value returned from the function or functor provided. */template<typenameF>T*ptrOrFrom(F&&aFunc){if(isSome()){returnptr();}returnaFunc();}template<typenameF>constT*ptrOrFrom(F&&aFunc)const{if(isSome()){returnptr();}returnaFunc();}T*operator->(){MOZ_ASSERT(mIsSome);returnptr();}constT*operator->()const{MOZ_ASSERT(mIsSome);returnptr();}/* Returns the contents of this Maybe<T> by ref. Unsafe unless |isSome()|. */T&ref(){MOZ_ASSERT(mIsSome);return*static_cast<T*>(data());}constT&ref()const{MOZ_ASSERT(mIsSome);return*static_cast<constT*>(data());}/* * Returns the contents of this Maybe<T> by ref. If |isNothing()|, returns * the default value provided. */T&refOr(T&aDefault){if(isSome()){returnref();}returnaDefault;}constT&refOr(constT&aDefault)const{if(isSome()){returnref();}returnaDefault;}/* * Returns the contents of this Maybe<T> by ref. If |isNothing()|, returns the * value returned from the function or functor provided. */template<typenameF>T&refOrFrom(F&&aFunc){if(isSome()){returnref();}returnaFunc();}template<typenameF>constT&refOrFrom(F&&aFunc)const{if(isSome()){returnref();}returnaFunc();}T&operator*(){MOZ_ASSERT(mIsSome);returnref();}constT&operator*()const{MOZ_ASSERT(mIsSome);returnref();}/* If |isSome()|, runs the provided function or functor on the contents of * this Maybe. */template<typenameFunc>Maybe&apply(FuncaFunc){if(isSome()){aFunc(ref());}return*this;}template<typenameFunc>constMaybe&apply(FuncaFunc)const{if(isSome()){aFunc(ref());}return*this;}/* * If |isSome()|, runs the provided function and returns the result wrapped * in a Maybe. If |isNothing()|, returns an empty Maybe value. */template<typenameFunc>automap(FuncaFunc)->Maybe<decltype(aFunc(DeclVal<Maybe<T>>().ref()))>{usingReturnType=decltype(aFunc(ref()));if(isSome()){Maybe<ReturnType>val;val.emplace(aFunc(ref()));returnval;}returnMaybe<ReturnType>();}template<typenameFunc>automap(FuncaFunc)const->Maybe<decltype(aFunc(DeclVal<Maybe<T>>().ref()))>{usingReturnType=decltype(aFunc(ref()));if(isSome()){Maybe<ReturnType>val;val.emplace(aFunc(ref()));returnval;}returnMaybe<ReturnType>();}/* If |isSome()|, empties this Maybe and destroys its contents. */voidreset(){if(isSome()){ref().T::~T();mIsSome=false;}}/* * Constructs a T value in-place in this empty Maybe<T>'s storage. The * arguments to |emplace()| are the parameters to T's constructor. */template<typename...Args>voidemplace(Args&&...aArgs){MOZ_ASSERT(!mIsSome);::new(KnownNotNull,data())T(Forward<Args>(aArgs)...);mIsSome=true;}friendstd::ostream&operator<<(std::ostream&aStream,constMaybe<T>&aMaybe){if(aMaybe){aStream<<aMaybe.ref();}else{aStream<<"<Nothing>";}returnaStream;}};/* * Some() creates a Maybe<T> value containing the provided T value. If T has a * move constructor, it's used to make this as efficient as possible. * * Some() selects the type of Maybe it returns by removing any const, volatile, * or reference qualifiers from the type of the value you pass to it. This gives * it more intuitive behavior when used in expressions, but it also means that * if you need to construct a Maybe value that holds a const, volatile, or * reference value, you need to use emplace() instead. */template<typenameT,typenameU=typenamestd::remove_cv<typenamestd::remove_reference<T>::type>::type>Maybe<U>Some(T&&aValue){Maybe<U>value;value.emplace(Forward<T>(aValue));returnvalue;}template<typenameT>Maybe<typenameRemoveCV<typenameRemoveReference<T>::Type>::Type>ToMaybe(T*aPtr){if(aPtr){returnSome(*aPtr);}returnNothing();}/* * Two Maybe<T> values are equal if * - both are Nothing, or * - both are Some, and the values they contain are equal. */template<typenameT>booloperator==(constMaybe<T>&aLHS,constMaybe<T>&aRHS){if(aLHS.isNothing()!=aRHS.isNothing()){returnfalse;}returnaLHS.isNothing()||*aLHS==*aRHS;}template<typenameT>booloperator!=(constMaybe<T>&aLHS,constMaybe<T>&aRHS){return!(aLHS==aRHS);}/* * We support comparison to Nothing to allow reasonable expressions like: * if (maybeValue == Nothing()) { ... } */template<typenameT>booloperator==(constMaybe<T>&aLHS,constNothing&aRHS){returnaLHS.isNothing();}template<typenameT>booloperator!=(constMaybe<T>&aLHS,constNothing&aRHS){return!(aLHS==aRHS);}template<typenameT>booloperator==(constNothing&aLHS,constMaybe<T>&aRHS){returnaRHS.isNothing();}template<typenameT>booloperator!=(constNothing&aLHS,constMaybe<T>&aRHS){return!(aLHS==aRHS);}/* * Maybe<T> values are ordered in the same way T values are ordered, except that * Nothing comes before anything else. */template<typenameT>booloperator<(constMaybe<T>&aLHS,constMaybe<T>&aRHS){if(aLHS.isNothing()){returnaRHS.isSome();}if(aRHS.isNothing()){returnfalse;}return*aLHS<*aRHS;}template<typenameT>booloperator>(constMaybe<T>&aLHS,constMaybe<T>&aRHS){return!(aLHS<aRHS||aLHS==aRHS);}template<typenameT>booloperator<=(constMaybe<T>&aLHS,constMaybe<T>&aRHS){returnaLHS<aRHS||aLHS==aRHS;}template<typenameT>booloperator>=(constMaybe<T>&aLHS,constMaybe<T>&aRHS){return!(aLHS<aRHS);}}// namespace mozilla#endif /* mozilla_Maybe_h */