Use the RPC channel to set the ID <-> handle mapping....

ceee/ie/plugin/bho/browser_helper_object.cc

 // 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.
 //
 // IE browser helper object implementation.
 #include "ceee/ie/plugin/bho/browser_helper_object.h"
 
 #include <atlsafe.h>
 #include <shlguid.h>
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "base/json/json_reader.h"
+#include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/tuple.h"
 #include "base/utf_string_conversions.h"
 #include "ceee/common/com_utils.h"
 #include "ceee/common/window_utils.h"
 #include "ceee/common/windows_constants.h"
 #include "ceee/ie/broker/tab_api_module.h"
+#include "ceee/ie/common/constants.h"
 #include "ceee/ie/common/extension_manifest.h"
 #include "ceee/ie/common/ie_util.h"
 #include "ceee/ie/common/metrics_util.h"
 #include "ceee/ie/common/ceee_module_util.h"
 #include "ceee/ie/plugin/bho/cookie_accountant.h"
 #include "ceee/ie/plugin/bho/http_negotiate.h"
 #include "ceee/ie/plugin/scripting/script_host.h"
 #include "ceee/ie/plugin/toolband/toolband_proxy.h"
 #include "chrome/browser/automation/extension_automation_constants.h"
 #include "chrome/browser/extensions/extension_tabs_module_constants.h"
@@ skipping 277 matching lines @@
 }
 
 HRESULT BrowserHelperObject::UnregisterExecutor(DWORD thread_id) {
   base::win::ScopedComPtr<ICeeeBrokerRegistrar> registrar;
   HRESULT hr = GetBrokerRegistrar(registrar.Receive());
   if (FAILED(hr))
     return hr;
   return registrar->UnregisterExecutor(thread_id);
 }
 
-HRESULT BrowserHelperObject::SetTabToolBandIdForHandle(int tool_band_id,
-                                                       long tab_handle) {
-  base::win::ScopedComPtr<ICeeeBrokerRegistrar> registrar;
-  HRESULT hr = GetBrokerRegistrar(registrar.Receive());
-  if (FAILED(hr))
-    return hr;
-  return registrar->SetTabToolBandIdForHandle(tool_band_id, tab_handle);
-}
-
-HRESULT BrowserHelperObject::SetTabIdForHandle(int tool_band_id,
-                                               long tab_handle) {
-  base::win::ScopedComPtr<ICeeeBrokerRegistrar> registrar;
-  HRESULT hr = GetBrokerRegistrar(registrar.Receive());
-  if (FAILED(hr))
-    return hr;
-  return registrar->SetTabIdForHandle(tool_band_id, tab_handle);
-}
-
 HRESULT BrowserHelperObject::Initialize(IUnknown* site) {
   TRACE_EVENT_INSTANT("ceee.bho.initialize", this, "");
   mu::ScopedTimer metrics_timer("ceee/BHO.Initialize", &broker_rpc());
 
   HRESULT hr = ConnectRpcBrokerClient();
   if (FAILED(hr) || !broker_rpc().is_connected()) {
     // Cancel the logging. The BrokerRpcClient isn't ready.
     metrics_timer.Drop();
     NOTREACHED() << "Couldn't connect to the RPC server.";
     return com::AlwaysError(hr);
@@ skipping 281 matching lines @@
     return false;
   }
 
   // At this point if tab_id_ is still invalid we have a problem.
   if (tab_id_ == kInvalidChromeSessionId) {
     // Something really bad happened.
     NOTREACHED();
     return false;
   }
 
-  CeeeWindowHandle handle = reinterpret_cast<CeeeWindowHandle>(tab_window_);
-  hr = SetTabIdForHandle(tab_id_, handle);
+  hr = FireMapTabIdToHandle();
   if (FAILED(hr)) {
     DCHECK(SUCCEEDED(hr)) << "An error occured when setting the tab_id: " <<
         com::LogHr(hr);
     tab_id_ = kInvalidChromeSessionId;
     return false;
   }
-  VLOG(2) << "TabId(" << tab_id_ << ") set for Handle(" << handle << ")";
+  VLOG(2) << "TabId(" << tab_id_ << ") set for Handle(" << tab_window_ << ")";
 
   // Call back all the events we deferred. In order, please.
   while (!deferred_events_call_.empty()) {
     // We pop here so that if an error happens in the call we don't recall the
     // faulty method. This has the side-effect of losing events.
     DeferredCallListType::value_type call = deferred_events_call_.front();
     deferred_events_call_.pop_front();
     call->Run();
     delete call;
   }
@@ skipping 48 matching lines @@
     return hr;
   }
   return hr;
 }
 
 HRESULT BrowserHelperObject::CreateChromeFrameHost() {
   return ChromeFrameHost::CreateInitializedIID(chrome_frame_host_.iid(),
                                                chrome_frame_host_.Receive());
 }
 
+HRESULT BrowserHelperObject::SendIdMappingToBroker(const char* event_name,
+                                                   int id) {
+  // Event arguments for FireEvent need to be stored in a list.
+  VLOG(1) << "SendIdMappingToBroker(" << event_name << ", " << id << ")";
+  DCHECK(id != kInvalidChromeSessionId);
+  DCHECK(tab_window_ != NULL);
+
+  ListValue mapping_args;
+  mapping_args.Append(Value::CreateIntegerValue(id));
+  mapping_args.Append(Value::CreateIntegerValue(
+      reinterpret_cast<int>(tab_window_)));
+
+  std::string event_args_str;
+  base::JSONWriter::Write(&mapping_args, false, &event_args_str);
+  // We go directly to Impl version since we know we have Ensured Id...
+  return SendEventToBrokerImpl(event_name, event_args_str);
+}
+
+HRESULT BrowserHelperObject::FireMapTabIdToHandle() {
+  return SendIdMappingToBroker(ceee_event_names::kCeeeMapTabIdToHandle,
+                               tab_id_);
+}
+
+HRESULT BrowserHelperObject::FireMapToolbandIdToHandle(int toolband_id) {
+  return SendIdMappingToBroker(ceee_event_names::kCeeeMapToolbandIdToHandle,
+                               toolband_id);
+}
+
 void BrowserHelperObject::FireOnCreatedEvent(BSTR url) {
   DCHECK(url != NULL);
   DCHECK(tab_window_ != NULL);
   DCHECK(!fired_on_created_event_);
   // Avoid sending double-creation events. Also only fire the event if we're
   // NOT in full-tab mode, because by design, extensions are not supposed to be
   // aware of full-tab Chrome Frame tabs.
   if (fired_on_created_event_ || full_tab_chrome_frame_)
     return;
 
@@ skipping 832 matching lines @@
   if (sink == NULL)
     return;
 
   std::vector<Sink*>::iterator iter = std::find(sinks_.begin(), sinks_.end(),
                                                 sink);
   if (iter != sinks_.end())
     sinks_.erase(iter);
 }
 
 STDMETHODIMP BrowserHelperObject::SetToolBandSessionId(long session_id) {
-  CeeeWindowHandle handle = reinterpret_cast<CeeeWindowHandle>(tab_window_);
-  HRESULT hr = SetTabToolBandIdForHandle(session_id, handle);
+  HRESULT hr = FireMapToolbandIdToHandle(session_id);
   if (FAILED(hr)) {
     DCHECK(SUCCEEDED(hr)) << "An error occured when setting the toolband " <<
         "tab ID: " << com::LogHr(hr);
     return hr;
   }
-  VLOG(2) << "ToolBandTabId(" << session_id << ") set for Handle(" << handle <<
-      ")";
+  VLOG(2) << "ToolBandTabId(" << session_id << ") set for Handle(" <<
+      tab_window_ << ")";
   return hr;
 }
 
 HRESULT BrowserHelperObject::SendEventToBroker(const char* event_name,
                                                const char* event_args) {
   if (EnsureTabId() == false) {
     deferred_events_call_.push_back(NewRunnableMethod(
         this, &BrowserHelperObject::SendEventToBrokerImpl,
         std::string(event_name), std::string(event_args)));
     VLOG(2) << "Deferred SendEventToBroker. Name: \"" << event_name <<
       "\", args: \"" << event_args << "\".";
     return S_FALSE;
   } else {
     return SendEventToBrokerImpl(event_name, event_args);
   }
 }
 
 HRESULT BrowserHelperObject::SendEventToBrokerImpl(
     const std::string& event_name, const std::string& event_args) {
   return broker_rpc().FireEvent(event_name.c_str(), event_args.c_str());
 }