Move many ProcessSingleton methods to "protected" visibility as an upcoming refactoring of ProcessS…

chrome/browser/process_singleton_linux.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.
 
 // On Linux, when the user tries to launch a second copy of chrome, we check
 // for a socket in the user's profile directory.  If the socket file is open we
 // send a message to the first chrome browser process with the current
 // directory and second process command line flags.  The second process then
 // exits.
 //
@@ skipping 690 matching lines @@
   lock_path_ = user_data_dir.Append(chrome::kSingletonLockFilename);
   cookie_path_ = user_data_dir.Append(chrome::kSingletonCookieFilename);
 
   kill_callback_ = base::Bind(&ProcessSingleton::KillProcess,
                               base::Unretained(this));
 }
 
 ProcessSingleton::~ProcessSingleton() {
 }
 
+ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessOrCreate(
+    const NotificationCallback& notification_callback) {
+  return NotifyOtherProcessWithTimeoutOrCreate(
+      *CommandLine::ForCurrentProcess(),
+      notification_callback,
+      kTimeoutInSeconds);
+}
+
+void ProcessSingleton::Cleanup() {
+  UnlinkPath(socket_path_);
+  UnlinkPath(cookie_path_);
+  UnlinkPath(lock_path_);
+}
+
+void ProcessSingleton::DisablePromptForTesting() {
+  g_disable_prompt = true;
+}
+
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
   return NotifyOtherProcessWithTimeout(*CommandLine::ForCurrentProcess(),
                                        kTimeoutInSeconds,
                                        true);
 }
 
+bool ProcessSingleton::Create(
+    const NotificationCallback& notification_callback) {
+  int sock;
+  sockaddr_un addr;
+
+  // The symlink lock is pointed to the hostname and process id, so other
+  // processes can find it out.
+  FilePath symlink_content(base::StringPrintf(
+      "%s%c%u",
+      net::GetHostName().c_str(),
+      kLockDelimiter,
+      current_pid_));
+
+  // Create symbol link before binding the socket, to ensure only one instance
+  // can have the socket open.
+  if (!SymlinkPath(symlink_content, lock_path_)) {
+      // If we failed to create the lock, most likely another instance won the
+      // startup race.
+      return false;
+  }
+
+  // Create the socket file somewhere in /tmp which is usually mounted as a
+  // normal filesystem. Some network filesystems (notably AFS) are screwy and
+  // do not support Unix domain sockets.
+  if (!socket_dir_.CreateUniqueTempDir()) {
+    LOG(ERROR) << "Failed to create socket directory.";
+    return false;
+  }
+  // Setup the socket symlink and the two cookies.
+  FilePath socket_target_path =
+      socket_dir_.path().Append(chrome::kSingletonSocketFilename);
+  FilePath cookie(GenerateCookie());
+  FilePath remote_cookie_path =
+      socket_dir_.path().Append(chrome::kSingletonCookieFilename);
+  UnlinkPath(socket_path_);
+  UnlinkPath(cookie_path_);
+  if (!SymlinkPath(socket_target_path, socket_path_) ||
+      !SymlinkPath(cookie, cookie_path_) ||
+      !SymlinkPath(cookie, remote_cookie_path)) {
+    // We've already locked things, so we can't have lost the startup race,
+    // but something doesn't like us.
+    LOG(ERROR) << "Failed to create symlinks.";
+    if (!socket_dir_.Delete())
+      LOG(ERROR) << "Encountered a problem when deleting socket directory.";
+    return false;
+  }
+
+  SetupSocket(socket_target_path.value(), &sock, &addr);
+
+  if (bind(sock, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) {
+    PLOG(ERROR) << "Failed to bind() " << socket_target_path.value();
+    CloseSocket(sock);
+    return false;
+  }
+
+  if (listen(sock, 5) < 0)
+    NOTREACHED() << "listen failed: " << safe_strerror(errno);
+
+  notification_callback_ = notification_callback;
+
+  DCHECK(BrowserThread::IsMessageLoopValid(BrowserThread::IO));
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&ProcessSingleton::LinuxWatcher::StartListening,
+                 watcher_.get(),
+                 sock));
+
+  return true;
+}
+
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessWithTimeout(
     const CommandLine& cmd_line,
     int timeout_seconds,
     bool kill_unresponsive) {
   DCHECK_GE(timeout_seconds, 0);
 
   ScopedSocket socket;
   for (int retries = 0; retries <= timeout_seconds; ++retries) {
     // Try to connect to the socket.
     if (ConnectSocket(&socket, socket_path_, cookie_path_))
@@ skipping 101 matching lines @@
     gdk_notify_startup_complete();
 #endif
     // Assume the other process is handling the request.
     return PROCESS_NOTIFIED;
   }
 
   NOTREACHED() << "The other process returned unknown message: " << buf;
   return PROCESS_NOTIFIED;
 }
 
-ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessOrCreate(
-    const NotificationCallback& notification_callback) {
-  return NotifyOtherProcessWithTimeoutOrCreate(
-      *CommandLine::ForCurrentProcess(),
-      notification_callback,
-      kTimeoutInSeconds);
-}
-
 ProcessSingleton::NotifyResult
 ProcessSingleton::NotifyOtherProcessWithTimeoutOrCreate(
     const CommandLine& command_line,
     const NotificationCallback& notification_callback,
     int timeout_seconds) {
   NotifyResult result = NotifyOtherProcessWithTimeout(command_line,
                                                       timeout_seconds, true);
   if (result != PROCESS_NONE)
     return result;
   if (Create(notification_callback))
@@ skipping 12 matching lines @@
 
 void ProcessSingleton::OverrideCurrentPidForTesting(base::ProcessId pid) {
   current_pid_ = pid;
 }
 
 void ProcessSingleton::OverrideKillCallbackForTesting(
     const base::Callback<void(int)>& callback) {
   kill_callback_ = callback;
 }
 
-void ProcessSingleton::DisablePromptForTesting() {
-  g_disable_prompt = true;
-}
-
-bool ProcessSingleton::Create(
-    const NotificationCallback& notification_callback) {
-  int sock;
-  sockaddr_un addr;
-
-  // The symlink lock is pointed to the hostname and process id, so other
-  // processes can find it out.
-  FilePath symlink_content(base::StringPrintf(
-      "%s%c%u",
-      net::GetHostName().c_str(),
-      kLockDelimiter,
-      current_pid_));
-
-  // Create symbol link before binding the socket, to ensure only one instance
-  // can have the socket open.
-  if (!SymlinkPath(symlink_content, lock_path_)) {
-      // If we failed to create the lock, most likely another instance won the
-      // startup race.
-      return false;
-  }
-
-  // Create the socket file somewhere in /tmp which is usually mounted as a
-  // normal filesystem. Some network filesystems (notably AFS) are screwy and
-  // do not support Unix domain sockets.
-  if (!socket_dir_.CreateUniqueTempDir()) {
-    LOG(ERROR) << "Failed to create socket directory.";
-    return false;
-  }
-  // Setup the socket symlink and the two cookies.
-  FilePath socket_target_path =
-      socket_dir_.path().Append(chrome::kSingletonSocketFilename);
-  FilePath cookie(GenerateCookie());
-  FilePath remote_cookie_path =
-      socket_dir_.path().Append(chrome::kSingletonCookieFilename);
-  UnlinkPath(socket_path_);
-  UnlinkPath(cookie_path_);
-  if (!SymlinkPath(socket_target_path, socket_path_) ||
-      !SymlinkPath(cookie, cookie_path_) ||
-      !SymlinkPath(cookie, remote_cookie_path)) {
-    // We've already locked things, so we can't have lost the startup race,
-    // but something doesn't like us.
-    LOG(ERROR) << "Failed to create symlinks.";
-    if (!socket_dir_.Delete())
-      LOG(ERROR) << "Encountered a problem when deleting socket directory.";
-    return false;
-  }
-
-  SetupSocket(socket_target_path.value(), &sock, &addr);
-
-  if (bind(sock, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) {
-    PLOG(ERROR) << "Failed to bind() " << socket_target_path.value();
-    CloseSocket(sock);
-    return false;
-  }
-
-  if (listen(sock, 5) < 0)
-    NOTREACHED() << "listen failed: " << safe_strerror(errno);
-
-  notification_callback_ = notification_callback;
-
-  DCHECK(BrowserThread::IsMessageLoopValid(BrowserThread::IO));
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&ProcessSingleton::LinuxWatcher::StartListening,
-                 watcher_.get(),
-                 sock));
-
-  return true;
-}
-
-void ProcessSingleton::Cleanup() {
-  UnlinkPath(socket_path_);
-  UnlinkPath(cookie_path_);
-  UnlinkPath(lock_path_);
-}
-
 bool ProcessSingleton::IsSameChromeInstance(pid_t pid) {
   pid_t cur_pid = current_pid_;
   while (pid != cur_pid) {
     pid = base::GetParentProcessId(pid);
     if (pid < 0)
       return false;
     if (!IsChromeProcess(pid))
       return false;
   }
   return true;
@@ skipping 24 matching lines @@
 
 void ProcessSingleton::KillProcess(int pid) {
   // TODO(james.su@gmail.com): Is SIGKILL ok?
   int rv = kill(static_cast<base::ProcessHandle>(pid), SIGKILL);
   // ESRCH = No Such Process (can happen if the other process is already in
   // progress of shutting down and finishes before we try to kill it).
   DCHECK(rv == 0 || errno == ESRCH) << "Error killing process: "
                                     << safe_strerror(errno);
 }