Move more files from chrome/browser/nacl_host/ to components/nacl/browser/

components/nacl/browser/nacl_process_host.cc

 // Copyright (c) 2012 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.
 
-#include "chrome/browser/nacl_host/nacl_process_host.h"
+#include "components/nacl/browser/nacl_process_host.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/process/process_iterator.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
-#include "chrome/browser/nacl_host/nacl_host_message_filter.h"
-#include "chrome/common/chrome_switches.h"
 #include "components/nacl/browser/nacl_browser.h"
+#include "components/nacl/browser/nacl_host_message_filter.h"
 #include "components/nacl/common/nacl_cmd_line.h"
 #include "components/nacl/common/nacl_host_messages.h"
 #include "components/nacl/common/nacl_messages.h"
 #include "components/nacl/common/nacl_process_type.h"
 #include "components/nacl/common/nacl_switches.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/browser_ppapi_host.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_switches.h"
@@ skipping 10 matching lines @@
 
 #if defined(OS_POSIX)
 #include <fcntl.h>
 
 #include "ipc/ipc_channel_posix.h"
 #elif defined(OS_WIN)
 #include <windows.h>
 
 #include "base/threading/thread.h"
 #include "base/win/scoped_handle.h"
-#include "chrome/browser/nacl_host/nacl_broker_service_win.h"
+#include "components/nacl/browser/nacl_broker_service_win.h"
 #include "components/nacl/common/nacl_debug_exception_handler_win.h"
 #include "content/public/common/sandbox_init.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #endif
 
 using content::BrowserThread;
 using content::ChildProcessData;
 using content::ChildProcessHost;
 using ppapi::proxy::SerializedHandle;
 
@@ skipping 121 matching lines @@
 ppapi::PpapiPermissions GetNaClPermissions(uint32 permission_bits) {
   // Only allow NaCl plugins to request certain permissions. We don't want
   // a compromised renderer to be able to start a nacl plugin with e.g. Flash
   // permissions which may expand the surface area of the sandbox.
   uint32 masked_bits = permission_bits & ppapi::PERMISSION_DEV;
   return ppapi::PpapiPermissions::GetForCommandLine(masked_bits);
 }
 
 }  // namespace
 
+namespace nacl {
+
 struct NaClProcessHost::NaClInternal {
   NaClHandle socket_for_renderer;
   NaClHandle socket_for_sel_ldr;
 
   NaClInternal()
     : socket_for_renderer(NACL_INVALID_HANDLE),
       socket_for_sel_ldr(NACL_INVALID_HANDLE) { }
 };
 
 // -----------------------------------------------------------------------------
@@ skipping 51 matching lines @@
 
 NaClProcessHost::~NaClProcessHost() {
   // Report exit status only if the process was successfully started.
   if (process_->GetData().handle != base::kNullProcessHandle) {
     int exit_code = 0;
     process_->GetTerminationStatus(false /* known_dead */, &exit_code);
     std::string message =
         base::StringPrintf("NaCl process exited with status %i (0x%x)",
                            exit_code, exit_code);
     if (exit_code == 0) {
-      LOG(INFO) << message;
+      VLOG(1) << message;

[Mark Seaborn, 2013/11/22 20:41:48]

Why are you changing this?  Please undo this change.

     } else {
       LOG(ERROR) << message;
     }
   }
 
   if (internal_->socket_for_renderer != NACL_INVALID_HANDLE) {
     if (NaClClose(internal_->socket_for_renderer) != 0) {
       NOTREACHED() << "NaClClose() failed";
     }
   }
@@ skipping 14 matching lines @@
   if (process_launched_by_broker_) {
     NaClBrokerService::GetInstance()->OnLoaderDied();
   }
 #endif
 }
 
 void NaClProcessHost::OnProcessCrashed(int exit_status) {
   if (enable_crash_throttling_ &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePnaclCrashThrottling)) {
-    nacl::NaClBrowser::GetInstance()->OnProcessCrashed();
+    NaClBrowser::GetInstance()->OnProcessCrashed();
   }
 }
 
 // This is called at browser startup.
 // static
 void NaClProcessHost::EarlyStartup() {
-  nacl::NaClBrowser::GetInstance()->EarlyStartup();
+  NaClBrowser::GetInstance()->EarlyStartup();
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   // Open the IRT file early to make sure that it isn't replaced out from
   // under us by autoupdate.
-  nacl::NaClBrowser::GetInstance()->EnsureIrtAvailable();
+  NaClBrowser::GetInstance()->EnsureIrtAvailable();
 #endif
   CommandLine* cmd = CommandLine::ForCurrentProcess();
   UMA_HISTOGRAM_BOOLEAN(
       "NaCl.nacl-gdb",
       !cmd->GetSwitchValuePath(switches::kNaClGdb).empty());
   UMA_HISTOGRAM_BOOLEAN(
       "NaCl.nacl-gdb-script",
       !cmd->GetSwitchValuePath(switches::kNaClGdbScript).empty());
   UMA_HISTOGRAM_BOOLEAN(
       "NaCl.enable-nacl-debug",
       cmd->HasSwitch(switches::kEnableNaClDebug));
-  nacl::NaClBrowser::GetDelegate()->SetDebugPatterns(
+  NaClBrowser::GetDelegate()->SetDebugPatterns(
       cmd->GetSwitchValueASCII(switches::kNaClDebugMask));
 }
 
 void NaClProcessHost::Launch(
     NaClHostMessageFilter* nacl_host_message_filter,
     IPC::Message* reply_msg,
     const base::FilePath& manifest_path) {
   nacl_host_message_filter_ = nacl_host_message_filter;
   reply_msg_ = reply_msg;
   manifest_path_ = manifest_path;
 
   // Do not launch the requested NaCl module if NaCl is marked "unstable" due
   // to too many crashes within a given time period.
   if (enable_crash_throttling_ &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePnaclCrashThrottling) &&
-      nacl::NaClBrowser::GetInstance()->IsThrottled()) {
+      NaClBrowser::GetInstance()->IsThrottled()) {
     SendErrorToRenderer("Process creation was throttled due to excessive"
                         " crashes");
     delete this;
     return;
   }
 
   const CommandLine* cmd = CommandLine::ForCurrentProcess();
 #if defined(OS_WIN)
   if (cmd->HasSwitch(switches::kEnableNaClDebug) &&
       !cmd->HasSwitch(switches::kNoSandbox)) {
     // We don't switch off sandbox automatically for security reasons.
     SendErrorToRenderer("NaCl's GDB debug stub requires --no-sandbox flag"
                         " on Windows. See crbug.com/265624.");
     delete this;
     return;
   }
 #endif
   if (cmd->HasSwitch(switches::kNaClGdb) &&
       !cmd->HasSwitch(switches::kEnableNaClDebug)) {
     LOG(WARNING) << "--nacl-gdb flag requires --enable-nacl-debug flag";
   }
 
   // Start getting the IRT open asynchronously while we launch the NaCl process.
   // We'll make sure this actually finished in StartWithLaunchedProcess, below.
-  nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
+  NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
   nacl_browser->EnsureAllResourcesAvailable();
   if (!nacl_browser->IsOk()) {
     SendErrorToRenderer("could not find all the resources needed"
                         " to launch the process");
     delete this;
     return;
   }
 
   // Rather than creating a socket pair in the renderer, and passing
   // one side through the browser to sel_ldr, socket pairs are created
@@ skipping 58 matching lines @@
   CommandLine::StringType nacl_gdb =
       CommandLine::ForCurrentProcess()->GetSwitchValueNative(
           switches::kNaClGdb);
   CommandLine::StringVector argv;
   // We don't support spaces inside arguments in --nacl-gdb switch.
   base::SplitString(nacl_gdb, static_cast<CommandLine::CharType>(' '), &argv);
   CommandLine cmd_line(argv);
 #endif
   cmd_line.AppendArg("--eval-command");
   base::FilePath::StringType irt_path(
-      nacl::NaClBrowser::GetInstance()->GetIrtFilePath().value());
+      NaClBrowser::GetInstance()->GetIrtFilePath().value());
   // Avoid back slashes because nacl-gdb uses posix escaping rules on Windows.
   // See issue https://code.google.com/p/nativeclient/issues/detail?id=3482.
   std::replace(irt_path.begin(), irt_path.end(), '\\', '/');
   cmd_line.AppendArgNative(FILE_PATH_LITERAL("nacl-irt \"") + irt_path +
                            FILE_PATH_LITERAL("\""));
   if (!manifest_path_.empty()) {
     cmd_line.AppendArg("--eval-command");
     base::FilePath::StringType manifest_path_value(manifest_path_.value());
     std::replace(manifest_path_value.begin(), manifest_path_value.end(),
                  '\\', '/');
@@ skipping 41 matching lines @@
   int flags = ChildProcessHost::CHILD_NORMAL;
 #endif
 
   base::FilePath exe_path = ChildProcessHost::GetChildPath(flags);
   if (exe_path.empty())
     return false;
 
 #if defined(OS_WIN)
   // On Windows 64-bit NaCl loader is called nacl64.exe instead of chrome.exe
   if (RunningOnWOW64()) {
-    if (!nacl::NaClBrowser::GetInstance()->GetNaCl64ExePath(&exe_path)) {
+    if (!NaClBrowser::GetInstance()->GetNaCl64ExePath(&exe_path)) {
       SendErrorToRenderer("could not get path to nacl64.exe");
       return false;
     }
   }
 #endif
 
   scoped_ptr<CommandLine> cmd_line(new CommandLine(exe_path));
-  nacl::CopyNaClCommandLineArguments(cmd_line.get());
+  CopyNaClCommandLineArguments(cmd_line.get());
 
   cmd_line->AppendSwitchASCII(switches::kProcessType,
                               switches::kNaClLoaderProcess);
   cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id);
-  if (nacl::NaClBrowser::GetDelegate()->DialogsAreSuppressed())
+  if (NaClBrowser::GetDelegate()->DialogsAreSuppressed())
     cmd_line->AppendSwitch(switches::kNoErrorDialogs);
 
   if (!nacl_loader_prefix.empty())
     cmd_line->PrependWrapper(nacl_loader_prefix);
 
   // On Windows we might need to start the broker process to launch a new loader
 #if defined(OS_WIN)
   if (RunningOnWOW64()) {
     if (!NaClBrokerService::GetInstance()->LaunchLoader(
             weak_factory_.GetWeakPtr(), channel_id)) {
@@ skipping 33 matching lines @@
   return handled;
 }
 
 void NaClProcessHost::OnProcessLaunched() {
   if (!StartWithLaunchedProcess())
     delete this;
 }
 
 // Called when the NaClBrowser singleton has been fully initialized.
 void NaClProcessHost::OnResourcesReady() {
-  nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
+  NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
   if (!nacl_browser->IsReady()) {
     SendErrorToRenderer("could not acquire shared resources needed by NaCl");
     delete this;
   } else if (!SendStart()) {
     delete this;
   }
 }
 
 bool NaClProcessHost::ReplyToRenderer(
     const IPC::ChannelHandle& channel_handle) {
 #if defined(OS_WIN)
   // If we are on 64-bit Windows, the NaCl process's sandbox is
   // managed by a different process from the renderer's sandbox.  We
   // need to inform the renderer's sandbox about the NaCl process so
   // that the renderer can send handles to the NaCl process using
   // BrokerDuplicateHandle().
   if (RunningOnWOW64()) {
     if (!content::BrokerAddTargetPeer(process_->GetData().handle)) {
       SendErrorToRenderer("BrokerAddTargetPeer() failed");
       return false;
     }
   }
 #endif
 
-  nacl::FileDescriptor handle_for_renderer;
+  FileDescriptor handle_for_renderer;
 #if defined(OS_WIN)
   // Copy the handle into the renderer process.
   HANDLE handle_in_renderer;
   if (!DuplicateHandle(base::GetCurrentProcessHandle(),
                        reinterpret_cast<HANDLE>(
                            internal_->socket_for_renderer),
                        nacl_host_message_filter_->PeerHandle(),
                        &handle_in_renderer,
                        0,  // Unused given DUPLICATE_SAME_ACCESS.
                        FALSE,
                        DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS)) {
     SendErrorToRenderer("DuplicateHandle() failed");
     return false;
   }
-  handle_for_renderer = reinterpret_cast<nacl::FileDescriptor>(
+  handle_for_renderer = reinterpret_cast<FileDescriptor>(
       handle_in_renderer);
 #else
   // No need to dup the imc_handle - we don't pass it anywhere else so
   // it cannot be closed.
-  nacl::FileDescriptor imc_handle;
+  FileDescriptor imc_handle;
   imc_handle.fd = internal_->socket_for_renderer;
   imc_handle.auto_close = true;
   handle_for_renderer = imc_handle;
 #endif
 
   const ChildProcessData& data = process_->GetData();
   SendMessageToRenderer(
-      nacl::NaClLaunchResult(handle_for_renderer,
+      NaClLaunchResult(handle_for_renderer,
                              channel_handle,
                              base::GetProcId(data.handle),
                              data.id),
       std::string() /* error_message */);
   internal_->socket_for_renderer = NACL_INVALID_HANDLE;
   return true;
 }
 
 void NaClProcessHost::SendErrorToRenderer(const std::string& error_message) {
   LOG(ERROR) << "NaCl process launch failed: " << error_message;
-  SendMessageToRenderer(nacl::NaClLaunchResult(), error_message);
+  SendMessageToRenderer(NaClLaunchResult(), error_message);
 }
 
 void NaClProcessHost::SendMessageToRenderer(
-    const nacl::NaClLaunchResult& result,
+    const NaClLaunchResult& result,
     const std::string& error_message) {
   DCHECK(nacl_host_message_filter_);
   DCHECK(reply_msg_);
   if (nacl_host_message_filter_ != NULL && reply_msg_ != NULL) {
     NaClHostMsg_LaunchNaCl::WriteReplyParams(
         reply_msg_, result, error_message);
     nacl_host_message_filter_->Send(reply_msg_);
     nacl_host_message_filter_ = NULL;
     reply_msg_ = NULL;
   }
 }
 
 // TCP port we chose for NaCl debug stub. It can be any other number.
 static const int kDebugStubPort = 4014;
 
 #if defined(OS_POSIX)
 net::SocketDescriptor NaClProcessHost::GetDebugStubSocketHandle() {
-  nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
+  NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
   net::SocketDescriptor s = net::kInvalidSocket;
   // We allocate currently unused TCP port for debug stub tests. The port
   // number is passed to the test via debug stub port listener.
   if (nacl_browser->HasGdbDebugStubPortListener()) {
     int port;
     s = net::TCPListenSocket::CreateAndBindAnyPort("127.0.0.1", &port);
     if (s != net::kInvalidSocket) {
       nacl_browser->FireGdbDebugStubPortOpened(port);
     }
   } else {
     s = net::TCPListenSocket::CreateAndBind("127.0.0.1", kDebugStubPort);
   }
   if (s == net::kInvalidSocket) {
     LOG(ERROR) << "failed to open socket for debug stub";
     return net::kInvalidSocket;
   }
   if (listen(s, 1)) {
     LOG(ERROR) << "listen() failed on debug stub socket";
     if (HANDLE_EINTR(close(s)) < 0)
       PLOG(ERROR) << "failed to close debug stub socket";
     return net::kInvalidSocket;
   }
   return s;
 }
 #endif
 
 bool NaClProcessHost::StartNaClExecution() {
-  nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
+  NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
 
-  nacl::NaClStartParams params;
+  NaClStartParams params;
   params.validation_cache_enabled = nacl_browser->ValidationCacheIsEnabled();
   params.validation_cache_key = nacl_browser->GetValidationCacheKey();
-  params.version = nacl::NaClBrowser::GetDelegate()->GetVersionString();
+  params.version = NaClBrowser::GetDelegate()->GetVersionString();
   params.enable_exception_handling = enable_exception_handling_;
   params.enable_debug_stub = enable_debug_stub_ &&
-      nacl::NaClBrowser::GetDelegate()->URLMatchesDebugPatterns(manifest_url_);
+      NaClBrowser::GetDelegate()->URLMatchesDebugPatterns(manifest_url_);
   // Enable PPAPI proxy channel creation only for renderer processes.
   params.enable_ipc_proxy = enable_ppapi_proxy();
   params.uses_irt = uses_irt_;
   params.enable_dyncode_syscalls = enable_dyncode_syscalls_;
 
   const ChildProcessData& data = process_->GetData();
   if (!ShareHandleToSelLdr(data.handle,
                            internal_->socket_for_sel_ldr, true,
                            &params.handles)) {
     return false;
@@ skipping 13 matching lines @@
   // mappable with PROT_EXEC.  Rather than requiring an extra IPC
   // round trip out of the sandbox, we create an FD here.
   base::SharedMemory memory_buffer;
   base::SharedMemoryCreateOptions options;
   options.size = 1;
   options.executable = true;
   if (!memory_buffer.Create(options)) {
     DLOG(ERROR) << "Failed to allocate memory buffer";
     return false;
   }
-  nacl::FileDescriptor memory_fd;
+  FileDescriptor memory_fd;
   memory_fd.fd = dup(memory_buffer.handle().fd);
   if (memory_fd.fd < 0) {
     DLOG(ERROR) << "Failed to dup() a file descriptor";
     return false;
   }
   memory_fd.auto_close = true;
   params.handles.push_back(memory_fd);
 #endif
 
 #if defined(OS_POSIX)
   if (params.enable_debug_stub) {
     net::SocketDescriptor server_bound_socket = GetDebugStubSocketHandle();
     if (server_bound_socket != net::kInvalidSocket) {
       params.debug_stub_server_bound_socket =
-          nacl::FileDescriptor(server_bound_socket, true);
+          FileDescriptor(server_bound_socket, true);
     }
   }
 #endif
 
   process_->Send(new NaClProcessMsg_Start(params));
 
   internal_->socket_for_sel_ldr = NACL_INVALID_HANDLE;
   return true;
 }
 
@@ skipping 42 matching lines @@
     for (size_t i = 0; i < arraysize(flag_whitelist); ++i) {
       std::string value = cmdline->GetSwitchValueASCII(flag_whitelist[i]);
       if (!value.empty()) {
         args.switch_names.push_back(flag_whitelist[i]);
         args.switch_values.push_back(value);
       }
     }
 
     ppapi_host_->GetPpapiHost()->AddHostFactoryFilter(
         scoped_ptr<ppapi::host::HostFactory>(
-            nacl::NaClBrowser::GetDelegate()->CreatePpapiHostFactory(
+            NaClBrowser::GetDelegate()->CreatePpapiHostFactory(
                 ppapi_host_.get())));
 
     // Send a message to create the NaCl-Renderer channel. The handle is just
     // a place holder.
     ipc_proxy_channel_->Send(
         new PpapiMsg_CreateNaClChannel(
             nacl_host_message_filter_->render_process_id(),
             args,
             SerializedHandle(SerializedHandle::CHANNEL_HANDLE,
                              IPC::InvalidPlatformFileForTransit())));
@@ skipping 13 matching lines @@
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(NaClProcessHost, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_ChannelCreated,
                         OnPpapiChannelCreated)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool NaClProcessHost::StartWithLaunchedProcess() {
-  nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
+  NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
 
   if (nacl_browser->IsReady()) {
     return SendStart();
   } else if (nacl_browser->IsOk()) {
     nacl_browser->WaitForResources(
         base::Bind(&NaClProcessHost::OnResourcesReady,
                    weak_factory_.GetWeakPtr()));
     return true;
   } else {
     SendErrorToRenderer("previously failed to acquire shared resources");
     return false;
   }
 }
 
 void NaClProcessHost::OnQueryKnownToValidate(const std::string& signature,
                                              bool* result) {
-  nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
+  NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
   *result = nacl_browser->QueryKnownToValidate(signature, off_the_record_);
 }
 
 void NaClProcessHost::OnSetKnownToValidate(const std::string& signature) {
-  nacl::NaClBrowser::GetInstance()->SetKnownToValidate(
+  NaClBrowser::GetInstance()->SetKnownToValidate(
       signature, off_the_record_);
 }
 
 void NaClProcessHost::FileResolved(
     base::PlatformFile* file,
     const base::FilePath& file_path,
     IPC::Message* reply_msg) {
   if (*file != base::kInvalidPlatformFileValue) {
     IPC::PlatformFileForTransit handle = IPC::GetFileHandleForProcess(
         *file,
@@ skipping 32 matching lines @@
   // not be a problem, if needed.
   //
   // Each NaCl process will consume 2-3 entries because the manifest and main
   // nexe are currently not resolved.  Shared libraries will be resolved.  They
   // will be loaded sequentially, so they will only consume a single entry
   // while the load is in flight.
   //
   // TODO(ncbray): track behavior with UMA. If entries are getting evicted or
   // bogus keys are getting queried, this would be good to know.
   base::FilePath file_path;
-  if (!nacl::NaClBrowser::GetInstance()->GetFilePath(
+  if (!NaClBrowser::GetInstance()->GetFilePath(
         file_token_lo, file_token_hi, &file_path)) {
     NaClProcessMsg_ResolveFileToken::WriteReplyParams(
         reply_msg,
         IPC::InvalidPlatformFileForTransit(),
         base::FilePath(FILE_PATH_LITERAL("")));
     Send(reply_msg);
     return;
   }
 
   // Scratch space to share between the callbacks.
   base::PlatformFile* data = new base::PlatformFile();
 
   // Open the file.
   if (!content::BrowserThread::PostBlockingPoolTaskAndReply(
           FROM_HERE,
-          base::Bind(nacl::OpenNaClExecutableImpl,
+          base::Bind(OpenNaClExecutableImpl,
                      file_path, data),
           base::Bind(&NaClProcessHost::FileResolved,
                      weak_factory_.GetWeakPtr(),
                      base::Owned(data),
                      file_path,
                      reply_msg))) {
      NaClProcessMsg_ResolveFileToken::WriteReplyParams(
          reply_msg,
          IPC::InvalidPlatformFileForTransit(),
          base::FilePath(FILE_PATH_LITERAL("")));
@@ skipping 62 matching lines @@
   } else {
     NaClStartDebugExceptionHandlerThread(
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
+
+}  // namespace nacl