COM replaced with RPC for firing events in broker....

ceee/ie/plugin/toolband/toolband_module.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.
 //
 // Declaration of ATL module object and DLL exports.
 
 #include "base/at_exit.h"
 #include "base/atomic_ref_count.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/logging_win.h"
 #include "base/thread.h"
 #include "ceee/common/com_utils.h"
 #include "ceee/common/install_utils.h"
+#include "ceee/ie/broker/broker_rpc_client.h"
 #include "ceee/ie/common/ceee_module_util.h"
 #include "ceee/ie/plugin/bho/browser_helper_object.h"
 #include "ceee/ie/plugin/bho/executor.h"
 #include "ceee/ie/plugin/toolband/toolband_module_reporting.h"
 #include "ceee/ie/plugin/toolband/tool_band.h"
 #include "ceee/ie/plugin/scripting/script_host.h"
 #include "ceee/common/windows_constants.h"
 #include "chrome/common/url_constants.h"
 
 #include "toolband.h"  // NOLINT
@@ skipping 34 matching lines @@
   bool module_initialized() const {
     return module_initialized_;
   }
 
   // Fires an event to the broker, so that the call can be made with an
   // instance of a broker proxy that was CoCreated in the worker thread.
   void FireEventToBroker(const std::string& event_name,
                          const std::string& event_args);
 
  private:
+  // TODO(vitalybuka@google.com): Fire events without this thread.
   class ComWorkerThread : public base::Thread {
    public:
     ComWorkerThread();
 
     // Called just prior to starting the message loop
     virtual void Init();
 
     // Called just after the message loop ends
     virtual void CleanUp();
 
     // Called by FireEventTask so that the broker we instantiate in the
     // worker thread can be used.
     void FireEventToBroker(BSTR event_name, BSTR event_args);
    protected:
-    CComPtr<ICeeeBroker> broker_;
-    static const int kMaxNumberOfRetries = 5;
-    static const int64 kRetryDelayMs = 10;
-    int current_number_of_retries_;
+    BrokerRpcClient broker_rpc_;
   };
 
   class FireEventTask : public Task {
    public:
     FireEventTask(ComWorkerThread* worker_thread,
                   const std::string& event_name,
                   const std::string& event_args)
         : worker_thread_(worker_thread),
           event_name_(event_name.c_str()),
           event_args_(event_args.c_str()) {
     }
-    FireEventTask(ComWorkerThread* worker_thread,
-                  const BSTR event_name,
-                  const BSTR event_args)
-        : worker_thread_(worker_thread),
-          event_name_(event_name),
-          event_args_(event_args) {
-    }
     virtual void Run() {
       worker_thread_->FireEventToBroker(event_name_, event_args_);
     }
    private:
     ComWorkerThread* worker_thread_;
     CComBSTR event_name_;
     CComBSTR event_args_;
   };
   // We only start the thread on first use. If we would start it on
   // initialization, when our DLL is loaded into the broker process,
@@ skipping 169 matching lines @@
     message_loop->PostTask(FROM_HERE,
         new FireEventTask(worker_thread_, event_name, event_args));
   } else {
     LOG(ERROR) << "Trying to post a message before the COM worker thread is"
                   "completely initialized and ready.";
   }
 }
 
 
 ToolbandModule::ComWorkerThread::ComWorkerThread()
-    : base::Thread("CEEE-COM Worker Thread"),
-      current_number_of_retries_(0) {
+    : base::Thread("CEEE-COM Worker Thread") {
 }
 
 void ToolbandModule::ComWorkerThread::Init() {
   ::CoInitializeEx(0, COINIT_MULTITHREADED);
+  // TODO(vitalybuka@google.com): Start broker without COM.
+  CComPtr<ICeeeBroker> broker_;
   HRESULT hr = broker_.CoCreateInstance(CLSID_CeeeBroker);
   DCHECK(SUCCEEDED(hr)) << "Failed to create broker. " << com::LogHr(hr);
+  broker_rpc_.Connect();
+  DCHECK(broker_rpc_.is_connected());
+  ::CoUninitialize();
 }
 
 void ToolbandModule::ComWorkerThread::CleanUp() {
-  broker_.Release();
-  ::CoUninitialize();
+  broker_rpc_.Disconnect();
 }
 
 void ToolbandModule::ComWorkerThread::FireEventToBroker(BSTR event_name,
-                                                       BSTR event_args) {
-  DCHECK(broker_ != NULL);
-  if (broker_ != NULL) {
-    HRESULT hr = broker_->FireEvent(event_name, event_args);
-    if (SUCCEEDED(hr)) {
-      current_number_of_retries_ = 0;
-      return;
-    }
-    // If the server is busy (which can happen if it is calling in as we try to
-    // to call out to it), then we should retry a few times a little later.
-    if (current_number_of_retries_ < kMaxNumberOfRetries && message_loop()) {
-      ++current_number_of_retries_;
-      LOG(WARNING) << "Retrying Broker FireEvent Failure. " << com::LogHr(hr);
-      message_loop()->PostDelayedTask(FROM_HERE,
-          new FireEventTask(this, event_name, event_args), kRetryDelayMs);
-    } else {
-      current_number_of_retries_ = 0;
-      DCHECK(SUCCEEDED(hr)) << "Broker FireEvent Failed. " << com::LogHr(hr);
-    }
-  }
+                                                        BSTR event_args) {
+  DCHECK(broker_rpc_.is_connected());
+  bool result = broker_rpc_.FireEvent(event_name, event_args);
+  DCHECK(result);
 }
 
 ToolbandModule module;
 
 void ceee_module_util::AddRefModuleWorkerThread() {
   module.IncThreadRefCount();
 }
 void ceee_module_util::ReleaseModuleWorkerThread() {
   module.DecThreadRefCount();
 }
@@ skipping 59 matching lines @@
 }
 
 CEEE_DEFINE_DLL_REGISTER_SERVER()
 
 // DllUnregisterServer - Removes entries from the system registry
 STDAPI DllUnregisterServer(void) {
   // We always allow unregistration, even if no --enable-ceee install flag.
   HRESULT hr = module.DllUnregisterServer();
   return hr;
 }