Use BRANDING for IE CEEE. Simplify chrome_dll_version handling.

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>
 
@@ skipping 89 matching lines @@
       lower_bound_ready_state_(READYSTATE_UNINITIALIZED),
       ie7_or_later_(false),
       thread_id_(::GetCurrentThreadId()),
       full_tab_chrome_frame_(false) {
   TRACE_EVENT_BEGIN("ceee.bho", this, "");
   // Only the first call to this function really does anything.
   CookieAccountant::GetInstance()->PatchWininetFunctions();
 }
 
 BrowserHelperObject::~BrowserHelperObject() {
-  if (broker_rpc_ != NULL) {
+  if (broker_rpc_ != NULL)
     broker_rpc_->Disconnect();
-  }
 
   TRACE_EVENT_END("ceee.bho", this, "");
 }
 
 HRESULT BrowserHelperObject::FinalConstruct() {
   return S_OK;
 }
 
 void BrowserHelperObject::FinalRelease() {
   web_browser_.Release();
 }
 
 STDMETHODIMP BrowserHelperObject::SetSite(IUnknown* site) {
   typedef IObjectWithSiteImpl<BrowserHelperObject> SuperSite;
 
   // From experience, we know the site may be set multiple times.
   // Let's ignore second and subsequent set or unset.
-  if (NULL != site && NULL != m_spUnkSite.p ||
-      NULL == site && NULL == m_spUnkSite.p) {
+  if (site != NULL&& m_spUnkSite.p != NULL ||
+      site == NULL && m_spUnkSite.p == NULL ) {
     LOG(WARNING) << "Duplicate call to SetSite, previous site "
                  << m_spUnkSite.p << " new site " << site;
     return S_OK;
   }
 
   if (NULL == site) {
-    mu::ScopedTimer metrics_timer("ceee/BHO.TearDown", broker_rpc_.get());
+    if (broker_rpc_ != NULL)

[MAD, 2010/11/24 23:03:56]

You'll need to sync and merge again, this should be gone now... Stupid mistake
on my part... :-/

[Jói, 2010/11/25 23:13:41]

Done.

+      mu::ScopedTimer metrics_timer("ceee/BHO.TearDown", broker_rpc_.get());
 
     // We're being torn down.
     TearDown();
 
     FireOnRemovedEvent();
     // This call should be the last thing we send to the broker.
     FireOnUnmappedEvent();
   }
 
   HRESULT hr = SuperSite::SetSite(site);
   if (FAILED(hr))
     return hr;
 
   if (NULL != site) {
-    if (broker_rpc_ == NULL) {
-      // Unfortunately, we need to connect before taking performance. Including
-      // this call in our Timing would be useful. Unit tests make it
-      // complicated.
-      // TODO(hansl@chromium.org): Change initialization to be able to time
-      // this call too.
-      hr = ConnectRpcBrokerClient();
-      if (FAILED(hr) || !broker_rpc_->is_connected()) {
-        NOTREACHED() << "Couldn't connect to the RPC server.";
-        TearDown();
-        SuperSite::SetSite(NULL);
-      }
-    }
-
-    mu::ScopedTimer metrics_timer("ceee/BHO.Initialize", broker_rpc_.get());
     // We're being initialized.
     hr = Initialize(site);
 
     // Release the site, and tear down our own state in case of failure.
     if (FAILED(hr)) {
       TearDown();
       SuperSite::SetSite(NULL);
     }
   }
 
@@ skipping 82 matching lines @@
       new WebProgressNotifier());
   HRESULT hr = web_progress_notifier->Initialize(this, tab_window_,
                                                  web_browser_);
 
   return SUCCEEDED(hr) ? web_progress_notifier.release() : NULL;
 }
 
 HRESULT BrowserHelperObject::Initialize(IUnknown* site) {
   TRACE_EVENT_INSTANT("ceee.bho.initialize", this, "");
 
+  // We need to make sure the Broker is CoCreated BEFORE we try RPC to it.
+  HRESULT hr = GetBrokerRegistrar(&broker_registrar_);
+  DCHECK(SUCCEEDED(hr) && broker_registrar_) << "CoCreating Broker. " <<
+      com::LogHr(hr);
+  if (FAILED(hr) || !broker_registrar_)
+    return com::AlwaysError(hr);
+
+  // Unfortunately, we need to connect before taking performance. Including
+  // this call in our Timing would be useful. Unit tests make it
+  // complicated.
+  // TODO(hansl@chromium.org): Change initialization to be able to time
+  // this call too.
+  DCHECK(broker_rpc_ == NULL);
+  hr = ConnectRpcBrokerClient();
+  if (FAILED(hr) || !broker_rpc_->is_connected()) {
+    NOTREACHED() << "Couldn't connect to the RPC server.";
+    return com::AlwaysError(hr);
+  }
+  mu::ScopedTimer metrics_timer("ceee/BHO.Initialize", broker_rpc_.get());
+
   ie7_or_later_ = ie_util::GetIeVersion() > ie_util::IEVERSION_IE6;
 
-  HRESULT hr = InitializeChromeFrameHost();
+  hr = InitializeChromeFrameHost();
   DCHECK(SUCCEEDED(hr)) << "InitializeChromeFrameHost failed " <<
       com::LogHr(hr);
   if (FAILED(hr)) {
     return hr;
   }
 
   // Initialize the extension port manager.
   extension_port_manager_.Initialize(chrome_frame_host_);
 
   // Register the proxy/stubs for the executor.
   // Note the proxy registration function will have logged what occurred.
   hr = RegisterProxies();
   if (FAILED(hr))
     return hr;
 
   // Preemptively feed the broker with an executor in our thread.
-  hr = GetBrokerRegistrar(&broker_registrar_);
-  LOG_IF(ERROR, FAILED(hr)) << "Failed to create broker, hr=" <<
+  DCHECK(executor_ == NULL);
+  hr = CreateExecutor(&executor_);
+  LOG_IF(ERROR, FAILED(hr)) << "Failed to create Executor, hr=" <<
       com::LogHr(hr);
-  DCHECK(SUCCEEDED(hr)) << "CoCreating Broker. " << com::LogHr(hr);
+  DCHECK(SUCCEEDED(hr)) << "CoCreating Executor. " << com::LogHr(hr);
   if (SUCCEEDED(hr)) {
-    DCHECK(executor_ == NULL);
-    hr = CreateExecutor(&executor_);
-    LOG_IF(ERROR, FAILED(hr)) << "Failed to create Executor, hr=" <<
-        com::LogHr(hr);
-    DCHECK(SUCCEEDED(hr)) << "CoCreating Executor. " << com::LogHr(hr);
-    if (SUCCEEDED(hr)) {
-      // TODO(mad@chromium.org): Implement the proper manual/secure
-      // registration.
-      hr = broker_registrar_->RegisterTabExecutor(::GetCurrentThreadId(),
-                                                  executor_);
-      DCHECK(SUCCEEDED(hr)) << "Registering Executor. " << com::LogHr(hr);
-    }
+    // TODO(mad@chromium.org): Implement the proper manual/secure
+    // registration.
+    hr = broker_registrar_->RegisterTabExecutor(::GetCurrentThreadId(),
+                                                executor_);
+    DCHECK(SUCCEEDED(hr)) << "Registering Executor. " << com::LogHr(hr);
   }
+  if (FAILED(hr))
+    return hr;
 
   // We need the service provider for both the sink connections and
   // to get a handle to the tab window.
   CComQIPtr<IServiceProvider> service_provider(site);
   DCHECK(service_provider);
   if (service_provider == NULL) {
     return E_FAIL;
   }
 
   hr = ConnectSinks(service_provider);
@@ skipping 96 matching lines @@
     chrome_frame_host_->SetEventSink(NULL);
 
     LOG(ERROR) << "Failed to start chrome frame " << com::LogHr(hr);
     return hr;
   }
 
   return hr;
 }
 
 HRESULT BrowserHelperObject::OnCfReadyStateChanged(LONG state) {
-  // If EnsureTabId() returns false, the session_id isn't available.
-  // This means that the ExternalTab hasn't been created yet, which is certainly
-  // a bug. Calling this here will also ensure we call all the deferred calls if
-  // they haven't been called yet.
-  bool id_available = EnsureTabId();
-  if (!id_available) {
-    NOTREACHED();
-    return E_UNEXPECTED;
-  }
+  if (state == READYSTATE_COMPLETE) {
+    // If EnsureTabId() returns false, the session_id isn't available.
+    // This means that the ExternalTab hasn't been created yet, which is certainly
+    // a bug. Calling this here will also ensure we call all the deferred calls if
+    // they haven't been called yet.
+    bool id_available = EnsureTabId();
+    if (!id_available) {
+      NOTREACHED();
+      return E_UNEXPECTED;
+    }
 
-  if (state == READYSTATE_COMPLETE) {
     extension_path_ = ceee_module_util::GetExtensionPath();
 
     if (ceee_module_util::IsCrxOrEmpty(extension_path_) &&
         ceee_module_util::NeedToInstallExtension()) {
       LOG(INFO) << "Installing extension: \"" << extension_path_ << "\"";
       chrome_frame_host_->InstallExtension(CComBSTR(extension_path_.c_str()));
     } else {
       // In the case where we don't have a CRX (or we don't need to install it),
       // we must ask for the currently enabled extension before we can decide
       // what we need to do.
@@ skipping 330 matching lines @@
     deferred_tab_id_call_.push_back(NewRunnableMethod(
         this, &BrowserHelperObject::OnBeforeNavigate2Impl,
         ScopedDispatchPtr(webbrowser_disp), url_bstr));
   } else {
     OnBeforeNavigate2Impl(ScopedDispatchPtr(webbrowser_disp), url_bstr);
   }
 }
 
 void BrowserHelperObject::OnBeforeNavigate2Impl(
     const ScopedDispatchPtr& webbrowser_disp, const CComBSTR& url) {
-  mu::ScopedTimer metrics_timer("ceee/BHO.BeforeNavigate", broker_rpc_.get());
+  if (broker_rpc_ != NULL)
+    mu::ScopedTimer metrics_timer("ceee/BHO.BeforeNavigate", broker_rpc_.get());
 
   base::win::ScopedComPtr<IWebBrowser2> webbrowser;
   HRESULT hr = webbrowser.QueryFrom(webbrowser_disp);
   if (FAILED(hr)) {
     LOG(ERROR) << "OnBeforeNavigate2 failed to QI " << com::LogHr(hr);
     return;
   }
 
   for (std::vector<Sink*>::iterator iter = sinks_.begin();
        iter != sinks_.end(); ++iter) {
@@ skipping 44 matching lines @@
     deferred_tab_id_call_.push_back(NewRunnableMethod(
         this, &BrowserHelperObject::OnDocumentCompleteImpl,
         webbrowser, url_bstr));
   } else {
     OnDocumentCompleteImpl(webbrowser, url_bstr);
   }
 }
 
 void BrowserHelperObject::OnDocumentCompleteImpl(
     const ScopedWebBrowser2Ptr& webbrowser, const CComBSTR& url) {
-  mu::ScopedTimer metrics_timer("ceee/BHO.DocumentComplete", broker_rpc_.get());
+  if (broker_rpc_ != NULL) {
+    mu::ScopedTimer metrics_timer("ceee/BHO.DocumentComplete",
+                                  broker_rpc_.get());
+  }
   for (std::vector<Sink*>::iterator iter = sinks_.begin();
        iter != sinks_.end(); ++iter) {
     (*iter)->OnDocumentComplete(webbrowser, url);
   }
 }
 
 STDMETHODIMP_(void) BrowserHelperObject::OnNavigateComplete2(
     IDispatch* webbrowser_disp, VARIANT* url) {
   if (webbrowser_disp == NULL || url == NULL) {
     LOG(ERROR) << "OnNavigateComplete2 got invalid parameter(s)";
@@ skipping 18 matching lines @@
     deferred_tab_id_call_.push_back(NewRunnableMethod(
         this, &BrowserHelperObject::OnNavigateComplete2Impl,
             webbrowser, url_bstr));
   } else {
     BrowserHelperObject::OnNavigateComplete2Impl(webbrowser, url_bstr);
   }
 }
 
 void BrowserHelperObject::OnNavigateComplete2Impl(
     const ScopedWebBrowser2Ptr& webbrowser, const CComBSTR& url) {
-  mu::ScopedTimer metrics_timer("ceee/BHO.NavigateComplete", broker_rpc_.get());
+  if (broker_rpc_ != NULL) {
+    mu::ScopedTimer metrics_timer("ceee/BHO.NavigateComplete",
+                                  broker_rpc_.get());
+  }
 
   HandleNavigateComplete(webbrowser, url);
 
   for (std::vector<Sink*>::iterator iter = sinks_.begin();
        iter != sinks_.end(); ++iter) {
     (*iter)->OnNavigateComplete(webbrowser, url);
   }
 }
 
 STDMETHODIMP_(void) BrowserHelperObject::OnNavigateError(
@@ skipping 30 matching lines @@
         this, &BrowserHelperObject::OnNavigateErrorImpl,
         webbrowser, url_bstr, status));
   } else {
     OnNavigateErrorImpl(webbrowser, url_bstr, status);
   }
 }
 
 void BrowserHelperObject::OnNavigateErrorImpl(
     const ScopedWebBrowser2Ptr& webbrowser, const CComBSTR& url,
     LONG status_code) {
-  mu::ScopedTimer metrics_timer("ceee/BHO.NavigateError", broker_rpc_.get());
+  if (broker_rpc_ != NULL)
+    mu::ScopedTimer metrics_timer("ceee/BHO.NavigateError", broker_rpc_.get());
 
   for (std::vector<Sink*>::iterator iter = sinks_.begin();
        iter != sinks_.end(); ++iter) {
     (*iter)->OnNavigateError(webbrowser, url, status_code);
   }
 }
 
 STDMETHODIMP_(void) BrowserHelperObject::OnNewWindow2(
     IDispatch** /*webbrowser_disp*/, VARIANT_BOOL* /*cancel*/) {
   // When a new window/tab is created, IE7 or later version of IE will also
@@ skipping 508 matching lines @@
   DCHECK(thread_id_ == ::GetCurrentThreadId());
 
   if (sink == NULL)
     return;
 
   std::vector<Sink*>::iterator iter = std::find(sinks_.begin(), sinks_.end(),
                                                 sink);
   if (iter != sinks_.end())
     sinks_.erase(iter);
 }