[Chromoting] Adding uiAccess='true' to the remoting_me2me_host.exe's manifest as it is required to …

remoting/host/win/launch_process_with_token.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 "remoting/host/win/launch_process_with_token.h"
 
 #include <windows.h>
 #include <winternl.h>
 
 #include "base/logging.h"
@@ skipping 85 matching lines @@
   return true;
 }
 
 // Requests the execution server to create a process in the specified session
 // using the default (i.e. Winlogon) token. This routine relies on undocumented
 // OS functionality and will likely not work on anything but XP or W2K3.
 bool CreateRemoteSessionProcess(
     uint32 session_id,
     const FilePath::StringType& application_name,
     const CommandLine::StringType& command_line,
+    DWORD creation_flags,
     PROCESS_INFORMATION* process_information_out)
 {
   DCHECK(base::win::GetVersion() == base::win::VERSION_XP);
 
   string16 pipe_name;
 
   // Use winsta!WinStationQueryInformationW() to determine the process creation
   // pipe name for the session.
   FilePath winsta_path(base::GetNativeLibraryName(UTF8ToUTF16("winsta")));
   base::ScopedNativeLibrary winsta(winsta_path);
@@ skipping 80 matching lines @@
   // and three NULL-terminated string parameters.
   size_t size = sizeof(CreateProcessRequest) + sizeof(wchar_t) *
       (application_name.size() + command_line.size() + desktop_name.size() + 3);
   scoped_array<char> buffer(new char[size]);
   memset(buffer.get(), 0, size);
 
   // Marshal the input parameters.
   CreateProcessRequest* request =
       reinterpret_cast<CreateProcessRequest*>(buffer.get());
   request->size = size;
+  request->process_id = GetCurrentProcessId();
   request->use_default_token = TRUE;
-  request->process_id = GetCurrentProcessId();
+  request->creation_flags = creation_flags;
   request->startup_info.cb = sizeof(request->startup_info);
 
   size_t buffer_offset = sizeof(CreateProcessRequest);
 
   request->application_name = reinterpret_cast<LPWSTR>(buffer_offset);
   std::copy(application_name.begin(),
             application_name.end(),
             reinterpret_cast<wchar_t*>(buffer.get() + buffer_offset));
   buffer_offset += (application_name.size() + 1) * sizeof(wchar_t);
 
@@ skipping 120 matching lines @@
   // Revert to the default token.
   CHECK(RevertToSelf());
 
   *token_out = session_token.Pass();
   return true;
 }
 
 bool LaunchProcessWithToken(const FilePath& binary,
                             const CommandLine::StringType& command_line,
                             HANDLE user_token,
-                            ScopedHandle* process_out) {
+                            DWORD creation_flags,
+                            ScopedHandle* process_out,
+                            ScopedHandle* thread_out) {
   FilePath::StringType application_name = binary.value();
 
   base::win::ScopedProcessInformation process_info;
   STARTUPINFOW startup_info;
 
   string16 desktop_name(UTF8ToUTF16(kDefaultDesktopName));
 
   memset(&startup_info, 0, sizeof(startup_info));
   startup_info.cb = sizeof(startup_info);
   startup_info.lpDesktop = const_cast<char16*>(desktop_name.c_str());
 
   BOOL result = CreateProcessAsUser(user_token,
                                     application_name.c_str(),
                                     const_cast<LPWSTR>(command_line.c_str()),
                                     NULL,
                                     NULL,
                                     FALSE,
-                                    0,
+                                    creation_flags,
                                     NULL,
                                     NULL,
                                     &startup_info,
                                     process_info.Receive());
 
   // CreateProcessAsUser will fail on XP and W2K3 with ERROR_PIPE_NOT_CONNECTED
   // if the user hasn't logged to the target session yet. In such a case
   // we try to talk to the execution server directly emulating what
   // the undocumented and not-exported advapi32!CreateRemoteSessionProcessW()
   // function does. The created process will run under Winlogon'a token instead
   // of |user_token|. Since Winlogon runs as SYSTEM, this suits our needs.
   if (!result &&
       GetLastError() == ERROR_PIPE_NOT_CONNECTED &&
       base::win::GetVersion() == base::win::VERSION_XP) {
     DWORD session_id;
     DWORD return_length;
     result = GetTokenInformation(user_token,
                                  TokenSessionId,
                                  &session_id,
                                  sizeof(session_id),
                                  &return_length);
     if (result && session_id != 0) {
       result = CreateRemoteSessionProcess(session_id,
                                           application_name,
                                           command_line,
+                                          creation_flags,
                                           process_info.Receive());
     } else {
       // Restore the error status returned by CreateProcessAsUser().
       result = FALSE;
       SetLastError(ERROR_PIPE_NOT_CONNECTED);
     }
   }
 
   if (!result) {
     LOG_GETLASTERROR(ERROR) <<
         "Failed to launch a process with a user token";
     return false;
   }
 
   CHECK(process_info.IsValid());
   process_out->Set(process_info.TakeProcessHandle());
+  thread_out->Set(process_info.TakeThreadHandle());
   return true;
 }
 
 } // namespace remoting