Mojo: Make GetDefault{AsyncWaiter,Logger} static methods of Environment.

mojo/public/cpp/bindings/interface_ptr.h

 // Copyright 2014 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 MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_PTR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_PTR_H_
 
 #include <assert.h>
 
 #include <algorithm>
 
 #include "mojo/public/cpp/bindings/error_handler.h"
 #include "mojo/public/cpp/bindings/lib/interface_ptr_internal.h"
+#include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 class ErrorHandler;
 
 // InterfacePtr represents a proxy to a remote instance of an interface.
 template <typename Interface>
 class InterfacePtr {
   MOJO_MOVE_ONLY_TYPE_FOR_CPP_03(InterfacePtr, RValue)
  public:
@@ skipping 24 matching lines @@
   // This method configures the InterfacePtr<..> to be a proxy to a remote
   // object on the other end of the given pipe.
   //
   // The proxy is bound to the current thread, which means its methods may
   // only be called on the current thread.
   //
   // To move a bound InterfacePtr<..> to another thread, call
   // ResetAndReturnMessagePipe. Then create a new InterfacePtr<..> on another
   // thread, and bind the new InterfacePtr<..> to the message pipe on that
   // thread.
-  void Bind(ScopedMessagePipeHandle handle,
-            const MojoAsyncWaiter* waiter = GetDefaultAsyncWaiter()) {
+  void Bind(
+      ScopedMessagePipeHandle handle,
+      const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
     reset();
     internal_state_.ConfigureProxy(handle.Pass(), waiter);
   }
 
   // The client interface may only be set after this InterfacePtr<..> is bound.
   void set_client(typename Interface::Client* client) {
     internal_state_.set_client(client);
   }
 
   // This method may be called to query if the underlying pipe has encountered
@@ skipping 33 matching lines @@
 };
 
 // Takes a handle to the proxy end-point of a pipe. On the other end is
 // presumed to be an interface implementation of type |Interface|. Returns a
 // generated proxy to that interface, which may be used on the current thread.
 // It is valid to call set_client on the returned InterfacePtr<..> to set an
 // instance of Interface::Client.
 template <typename Interface>
 InterfacePtr<Interface> MakeProxy(
     ScopedMessagePipeHandle handle,
-    const MojoAsyncWaiter* waiter = GetDefaultAsyncWaiter()) {
+    const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
   InterfacePtr<Interface> ptr;
   if (handle.is_valid())
     ptr.Bind(handle.Pass(), waiter);
   return ptr.Pass();
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_PTR_H_