3rd try. *sigh*...

chrome_frame/chrome_frame_automation.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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_frame/chrome_frame_automation.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/lock.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/waitable_event.h"
 #include "chrome/app/client_util.h"
 #include "chrome/common/chrome_constants.h"
-#include "chrome/common/chrome_paths.h"
-#include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome_frame/chrome_launcher.h"
 #include "chrome_frame/utils.h"
 #include "chrome_frame/sync_msg_reply_dispatcher.h"
 
 #ifdef NDEBUG
 int64 kAutomationServerReasonableLaunchDelay = 1000;  // in milliseconds
 #else
 int64 kAutomationServerReasonableLaunchDelay = 1000 * 10;
@@ skipping 230 matching lines @@
   command_line->AppendSwitch(switches::kNoErrorDialogs);
 #endif
 
   command_line->AppendSwitch(switches::kEnableRendererAccessibility);
 
   // In headless mode runs like reliability test runs we want full crash dumps
   // from chrome.
   if (IsHeadlessMode())
     command_line->AppendSwitch(switches::kFullMemoryCrashReport);
 
-  // Place the profile directory in
-  // "<chrome_exe_path>\..\User Data\<profile-name>"
-  if (!entry->profile_name.empty()) {
-    FilePath profile_path;
-    if (chrome::GetChromeFrameUserDataDirectory(&profile_path)) {
-      profile_path = profile_path.Append(entry->profile_name);
-      command_line->AppendSwitchWithValue(switches::kUserDataDir,
-          profile_path.value());
-    } else {
-      // Can't get the profile dir :-( We need one to work, so fail.
-      // We have no code for launch failure.
-      entry->launch_result = AutomationLaunchResult(-1);
-    }
-  }
+  DLOG(INFO) << "Profile path: " << params.profile_path.value();
+  command_line->AppendSwitchWithValue(switches::kUserDataDir,
+      params.profile_path.value());
 
   std::wstring command_line_string(command_line->command_line_string());
   // If there are any extra arguments, append them to the command line.
   if (!params.extra_chrome_arguments.empty()) {
     command_line_string += L' ' + params.extra_chrome_arguments;
   }
 
   automation_server_launch_start_time_ = base::TimeTicks::Now();
 
   if (!base::LaunchApp(command_line_string, false, false, NULL)) {
@@ skipping 34 matching lines @@
                                             AUTOMATION_CREATE_TAB_FAILED,
                                             AUTOMATION_CREATE_TAB_FAILED + 1);
   }
 
   // Finally set the proxy.
   entry->proxy = proxy;
   delegate->LaunchComplete(proxy, entry->launch_result);
 }
 
 bool ProxyFactory::ReleaseAutomationServer(void* server_id) {
-  DLOG(INFO) << __FUNCTION__;
-
   if (!server_id) {
     NOTREACHED();
     return false;
   }
 
   ProxyCacheEntry* entry = reinterpret_cast<ProxyCacheEntry*>(server_id);
 
 #ifndef NDEBUG
   lock_.Acquire();
   Vector::ContainerType::iterator it = std::find(proxies_.container().begin(),
@@ skipping 96 matching lines @@
 
 ChromeFrameAutomationClient::~ChromeFrameAutomationClient() {
   // Uninitialize must be called prior to the destructor
   DCHECK(automation_server_ == NULL);
 }
 
 bool ChromeFrameAutomationClient::Initialize(
     ChromeFrameDelegate* chrome_frame_delegate,
     int automation_server_launch_timeout,
     bool perform_version_check,
-    const std::wstring& profile_name,
+    const FilePath& profile_path,
     const std::wstring& extra_chrome_arguments,
     bool incognito) {
   DCHECK(!IsWindow());
   chrome_frame_delegate_ = chrome_frame_delegate;
   ui_thread_id_ = PlatformThread::CurrentId();
 #ifndef NDEBUG
   // In debug mode give more time to work with a debugger.
   if (IsDebuggerPresent()) {
     // Don't use INFINITE (which is -1) or even MAXINT since we will convert
     // from milliseconds to microseconds when stored in a base::TimeDelta,
@@ skipping 19 matching lines @@
   // Keep object in memory, while the window is alive.
   // Corresponsing Release is in OnFinalMessage();
   AddRef();
 
   // Mark our state as initializing.  We'll reach initialized once
   // InitializeComplete is called successfully.
   init_state_ = INITIALIZING;
 
   chrome_launch_params_.automation_server_launch_timeout =
       automation_server_launch_timeout;
-  chrome_launch_params_.profile_name = profile_name;
+  chrome_launch_params_.profile_path = profile_path;
+  chrome_launch_params_.profile_name = profile_path.BaseName().value();
   chrome_launch_params_.extra_chrome_arguments = extra_chrome_arguments;
   chrome_launch_params_.perform_version_check = perform_version_check;
   chrome_launch_params_.url = navigate_after_initialization_ ? GURL() : url_;
   chrome_launch_params_.incognito_mode = incognito;
 
   proxy_factory_->GetAutomationServer(
       static_cast<ProxyFactory::LaunchDelegate*>(this),
       chrome_launch_params_, &automation_server_id_);
 
   return true;
 }
 
 void ChromeFrameAutomationClient::Uninitialize() {
-  DLOG(INFO) << __FUNCTION__;
-
   if (init_state_ == UNINITIALIZED) {
     DLOG(WARNING) << __FUNCTION__ << ": Automation client not initialized";
     return;
   }
 
   init_state_ = UNINITIALIZING;
 
   // Called from client's FinalRelease() / destructor
   // ChromeFrameAutomationClient may wait for the initialization (launch)
   // to complete while Uninitialize is called.
@@ skipping 397 matching lines @@
         // Continue with Initialization - Create external tab
         CreateExternalTab();
       } else {
         // Send a notification to Chrome that we are ready to connect to the
         // ExternalTab.
         IPC::SyncMessage* message =
             new AutomationMsg_ConnectExternalTab(0, external_tab_cookie_, true,
               NULL, NULL, NULL);
         automation_server_->SendAsAsync(message, NewCallback(this,
             &ChromeFrameAutomationClient::CreateExternalTabComplete), this);
+        DLOG(INFO) << __FUNCTION__ << ": sending CreateExternalTabComplete";
       }
     }
   } else {
     // Launch failed. Note, we cannot delete proxy here.
     PostTask(FROM_HERE, NewRunnableMethod(this,
         &ChromeFrameAutomationClient::InitializeComplete, result));
   }
 }
 
 void ChromeFrameAutomationClient::InitializeComplete(
@@ skipping 149 matching lines @@
       ::GetClientRect(parent_window, &parent_client_rect);
       int width = parent_client_rect.right - parent_client_rect.left;
       int height = parent_client_rect.bottom - parent_client_rect.top;
 
       Resize(width, height, SWP_SHOWWINDOW | SWP_NOZORDER);
     }
   }
 }
 
 void ChromeFrameAutomationClient::ReleaseAutomationServer() {
-  DLOG(INFO) << __FUNCTION__;
   if (automation_server_id_) {
     // Cache the server id and clear the automation_server_id_ before
     // calling ReleaseAutomationServer.  The reason we do this is that
     // we must cancel pending messages before we release the automation server.
     // Furthermore, while ReleaseAutomationServer is running, we could get
     // a callback to LaunchComplete which is where we normally get our pointer
     // to the automation server and there we check the server id for NULLness
     // and do nothing if it is NULL.
     void* server_id = automation_server_id_;
     automation_server_id_ = NULL;
@@ skipping 97 matching lines @@
       font_size > LARGEST_FONT) {
       NOTREACHED() << "Invalid font size specified : "
                    << font_size;
       return;
   }
 
   automation_server_->Send(
       new AutomationMsg_SetPageFontSize(0, tab_handle_, font_size));
 }
 
+void ChromeFrameAutomationClient::RemoveBrowsingData(int remove_mask) {
+  automation_server_->Send(
+      new AutomationMsg_RemoveBrowsingData(0, remove_mask));
+}
 
 //////////////////////////////////////////////////////////////////////////
 // PluginUrlRequestDelegate implementation.
 // Forward network related responses to Chrome.
 
 void ChromeFrameAutomationClient::OnResponseStarted(int request_id,
     const char* mime_type,  const char* headers, int size,
     base::Time last_modified, const std::string& redirect_url,
     int redirect_status) {
   const IPC::AutomationURLResponse response = {
@@ skipping 15 matching lines @@
   automation_server_->Send(new AutomationMsg_RequestData(0, tab_->handle(),
       request_id, data));
 }
 
 void ChromeFrameAutomationClient::OnResponseEnd(int request_id,
     const URLRequestStatus& status) {
   automation_server_->Send(new AutomationMsg_RequestEnd(0, tab_->handle(),
       request_id, status));
 }