Use Scoped[Bstr,ComPtr,Variant] instead of their ATL equivalents to reduce de...

chrome/browser/importer/ie_importer.cc

 // Copyright (c) 2006-2008 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/browser/importer/ie_importer.h"
 
-#include <atlbase.h>
+#include <ole2.h>
 #include <intshcut.h>
 #include <pstore.h>
 #include <shlobj.h>
 #include <urlhist.h>
 
 #include <algorithm>
+#include <map>
+#include <string>
+#include <vector>
 
 #include "app/l10n_util.h"
 #include "app/win_util.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/registry.h"
+#include "base/scoped_comptr_win.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/win_util.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/password_manager/ie7_password.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/common/time_format.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
@@ skipping 32 matching lines @@
                              uint16 items,
                              ProfileWriter* writer,
                              MessageLoop* delagate_loop,
                              ImporterHost* host) {
   writer_ = writer;
   source_path_ = profile_info.source_path;
   importer_host_ = host;
 
   NotifyStarted();
 
-  // Some IE settings (such as Protected Storage) is obtained via COM APIs.
+  // Some IE settings (such as Protected Storage) are obtained via COM APIs.
   win_util::ScopedCOMInitializer com_initializer;
 
   if ((items & HOME_PAGE) && !cancelled())
     ImportHomepage();  // Doesn't have a UI item.
   // The order here is important!
   if ((items & FAVORITES) && !cancelled()) {
     NotifyItemStarted(FAVORITES);
     ImportFavorites();
     NotifyItemEnded(FAVORITES);
   }
@@ skipping 52 matching lines @@
   HMODULE pstorec_dll = LoadLibrary(L"pstorec.dll");
   if (!pstorec_dll)
     return;
   PStoreCreateFunc PStoreCreateInstance =
       (PStoreCreateFunc)GetProcAddress(pstorec_dll, "PStoreCreateInstance");
   if (!PStoreCreateInstance) {
     FreeLibrary(pstorec_dll);
     return;
   }
 
-  CComPtr<IPStore> pstore;
-  HRESULT result = PStoreCreateInstance(&pstore, 0, 0, 0);
+  ScopedComPtr<IPStore, &IID_IPStore> pstore;
+  HRESULT result = PStoreCreateInstance(pstore.Receive(), 0, 0, 0);
   if (result != S_OK) {
     FreeLibrary(pstorec_dll);
     return;
   }
 
   std::vector<AutoCompleteInfo> ac_list;
 
   // Enumerates AutoComplete items in the protected database.
-  CComPtr<IEnumPStoreItems> item;
+  ScopedComPtr<IEnumPStoreItems, &IID_IEnumPStoreItems> item;
   result = pstore->EnumItems(0, &AutocompleteGUID,
-                             &AutocompleteGUID, 0, &item);
+                             &AutocompleteGUID, 0, item.Receive());
   if (result != PST_E_OK) {
     pstore.Release();
     FreeLibrary(pstorec_dll);
     return;
   }
 
   wchar_t* item_name;
   while (!cancelled() && SUCCEEDED(item->Next(1, &item_name, 0))) {
     DWORD length = 0;
     unsigned char* buffer = NULL;
@@ skipping 107 matching lines @@
 }
 
 // Reads history information from COM interface.
 void IEImporter::ImportHistory() {
   const std::string kSchemes[] = {chrome::kHttpScheme,
                                   chrome::kHttpsScheme,
                                   chrome::kFtpScheme,
                                   chrome::kFileScheme};
   int total_schemes = arraysize(kSchemes);
 
-  CComPtr<IUrlHistoryStg2> url_history_stg2;
+  ScopedComPtr<IUrlHistoryStg2> url_history_stg2;
   HRESULT result;
-  result = url_history_stg2.CoCreateInstance(CLSID_CUrlHistory, NULL,
-                                             CLSCTX_INPROC_SERVER);
+  result = url_history_stg2.CreateInstance(CLSID_CUrlHistory, NULL,
+                                           CLSCTX_INPROC_SERVER);
   if (FAILED(result))
     return;
-  CComPtr<IEnumSTATURL> enum_url;
-  if (SUCCEEDED(result = url_history_stg2->EnumUrls(&enum_url))) {
+  ScopedComPtr<IEnumSTATURL> enum_url;
+  if (SUCCEEDED(result = url_history_stg2->EnumUrls(enum_url.Receive()))) {
     std::vector<history::URLRow> rows;
     STATURL stat_url;
     ULONG fetched;
     while (!cancelled() &&
            (result = enum_url->Next(1, &stat_url, &fetched)) == S_OK) {
       std::wstring url_string;
       std::wstring title_string;
       if (stat_url.pwcsUrl) {
         url_string = stat_url.pwcsUrl;
         CoTaskMemFree(stat_url.pwcsUrl);
@@ skipping 231 matching lines @@
         entry.path.insert(entry.path.begin(), ie_folder);
       bookmarks->push_back(entry);
     }
   }
   bookmarks->insert(bookmarks->begin(), toolbar_bookmarks.begin(),
                     toolbar_bookmarks.end());
 }
 
 std::wstring IEImporter::ResolveInternetShortcut(const std::wstring& file) {
   win_util::CoMemReleaser<wchar_t> url;
-  CComPtr<IUniformResourceLocator> url_locator;
-  HRESULT result = url_locator.CoCreateInstance(CLSID_InternetShortcut, NULL,
-                                                CLSCTX_INPROC_SERVER);
+  ScopedComPtr<IUniformResourceLocator> url_locator;
+  HRESULT result = url_locator.CreateInstance(CLSID_InternetShortcut, NULL,
+                                              CLSCTX_INPROC_SERVER);
   if (FAILED(result))
     return std::wstring();
 
-  CComPtr<IPersistFile> persist_file;
-  result = url_locator.QueryInterface(&persist_file);
+  ScopedComPtr<IPersistFile> persist_file;
+  result = persist_file.QueryFrom(url_locator);
   if (FAILED(result))
     return std::wstring();
 
   // Loads the Internet Shortcut from persistent storage.
   result = persist_file->Load(file.c_str(), STGM_READ);
   if (FAILED(result))
     return std::wstring();
 
   result = url_locator->GetURL(&url);
   // GetURL can return S_FALSE (FAILED(S_FALSE) is false) when url == NULL.
   if (FAILED(result) || (url == NULL))
     return std::wstring();
 
   return std::wstring(url);
 }
 
 int IEImporter::CurrentIEVersion() const {
   static int version = -1;
   if (version < 0) {
     wchar_t buffer[128];
     DWORD buffer_length = sizeof(buffer);
     bool result = ReadFromRegistry(HKEY_LOCAL_MACHINE,
         L"Software\\Microsoft\\Internet Explorer",
         L"Version", buffer, &buffer_length);
     version = (result ? _wtoi(buffer) : 0);
   }
   return version;
 }