Include base/win/scoped_comptr.h instead of base/scoped_comptr_win.h.

chrome/browser/jumplist_win.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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/jumplist_win.h"
 
 #include <windows.h>
 #include <shobjidl.h>
 #include <propkey.h>
 #include <propvarutil.h>
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
-#include "base/scoped_comptr_win.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
+#include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/favicon_service.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/page_usage_data.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 130 matching lines @@
  private:
   PROPVARIANT property_;
 
   DISALLOW_COPY_AND_ASSIGN(PropVariantString);
 };
 
 // Creates an IShellLink object.
 // An IShellLink object is almost the same as an application shortcut, and it
 // requires three items: the absolute path to an application, an argument
 // string, and a title string.
-HRESULT AddShellLink(ScopedComPtr<IObjectCollection> collection,
+HRESULT AddShellLink(base::win::ScopedComPtr<IObjectCollection> collection,
                      const std::wstring& application,
                      const std::wstring& switches,
                      scoped_refptr<ShellLinkItem> item) {
   // Create an IShellLink object.
-  ScopedComPtr<IShellLink> link;
+  base::win::ScopedComPtr<IShellLink> link;
   HRESULT result = link.CreateInstance(CLSID_ShellLink, NULL,
                                        CLSCTX_INPROC_SERVER);
   if (FAILED(result))
     return result;
 
   // Set the application path.
   // We should exit this function when this call fails because it doesn't make
   // any sense to add a shortcut that we cannot execute.
   result = link->SetPath(application.c_str());
   if (FAILED(result))
@@ skipping 24 matching lines @@
   // shortcut which doesn't have titles.
   // So, we should use the IPropertyStore interface to set its title as
   // listed in the steps below:
   // 1. Retrieve the IPropertyStore interface from the IShellLink object;
   // 2. Start a transaction that changes a value of the object with the
   //    IPropertyStore interface;
   // 3. Create a string PROPVARIANT, and;
   // 4. Call the IPropertyStore::SetValue() function to Set the title property
   //    of the IShellLink object.
   // 5. Commit the transaction.
-  ScopedComPtr<IPropertyStore> property_store;
+  base::win::ScopedComPtr<IPropertyStore> property_store;
   result = link.QueryInterface(property_store.Receive());
   if (FAILED(result))
     return result;
 
   PropVariantString property_title;
   result = property_title.Init(item->title());
   if (FAILED(result))
     return result;
 
   result = property_store->SetValue(PKEY_Title, property_title.Get());
@@ skipping 40 matching lines @@
 // * application (std::wstring)
 //   An application name to be used for creating JumpList items.
 //   Even though we can add command-line switches to this parameter, it is
 //   better to use the |switches| parameter below.
 // * switches (std::wstring)
 //   Command-lien switches for the application. This string is to be added
 //   before the arguments of each ShellLinkItem object. If there aren't any
 //   switches, use an empty string.
 // * data (ShellLinkItemList)
 //   A list of ShellLinkItem objects to be added under the specified category.
-HRESULT UpdateCategory(ScopedComPtr<ICustomDestinationList> list,
+HRESULT UpdateCategory(base::win::ScopedComPtr<ICustomDestinationList> list,
                        int category_id,
                        const std::wstring& application,
                        const std::wstring& switches,
                        const ShellLinkItemList& data,
                        int max_slots) {
   // Exit this function when the given vector does not contain any items
   // because an ICustomDestinationList::AppendCategory() call fails in this
   // case.
   if (data.empty() || !max_slots)
     return S_OK;
 
   std::wstring category = UTF16ToWide(l10n_util::GetStringUTF16(category_id));
 
   // Create an EnumerableObjectCollection object.
   // We once add the given items to this collection object and add this
   // collection to the JumpList.
-  ScopedComPtr<IObjectCollection> collection;
+  base::win::ScopedComPtr<IObjectCollection> collection;
   HRESULT result = collection.CreateInstance(CLSID_EnumerableObjectCollection,
                                              NULL, CLSCTX_INPROC_SERVER);
   if (FAILED(result))
     return false;
 
   for (ShellLinkItemList::const_iterator item = data.begin();
        item != data.end() && max_slots > 0; ++item, --max_slots) {
     scoped_refptr<ShellLinkItem> link(*item);
     AddShellLink(collection, application, switches, link);
   }
 
   // We can now add the new list to the JumpList.
   // The ICustomDestinationList::AppendCategory() function needs the
   // IObjectArray interface to retrieve each item in the list. So, we retrive
   // the IObjectArray interface from the IEnumeratableObjectCollection object
   // and use it.
   // It seems the ICustomDestinationList::AppendCategory() function just
   // replaces all items in the given category with the ones in the new list.
-  ScopedComPtr<IObjectArray> object_array;
+  base::win::ScopedComPtr<IObjectArray> object_array;
   result = collection.QueryInterface(object_array.Receive());
   if (FAILED(result))
     return false;
 
   return list->AppendCategory(category.c_str(), object_array);
 }
 
 // Updates the "Tasks" category of the JumpList.
 // Even though this function is almost the same as UpdateCategory(), this
 // function has the following differences:
 // * The "Task" category is a registered category.
 //   We should use AddUserTasks() instead of AppendCategory().
 // * The items in the "Task" category are static.
 //   We don't have to use a list.
-HRESULT UpdateTaskCategory(ScopedComPtr<ICustomDestinationList> list,
+HRESULT UpdateTaskCategory(base::win::ScopedComPtr<ICustomDestinationList> list,
                            const std::wstring& chrome_path,
                            const std::wstring& chrome_switches) {
   // Create an EnumerableObjectCollection object to be added items of the
   // "Task" category. (We can also use this object for the "Task" category.)
-  ScopedComPtr<IObjectCollection> collection;
+  base::win::ScopedComPtr<IObjectCollection> collection;
   HRESULT result = collection.CreateInstance(CLSID_EnumerableObjectCollection,
                                              NULL, CLSCTX_INPROC_SERVER);
   if (FAILED(result))
     return result;
 
   // Create an IShellLink object which launches Chrome, and add it to the
   // collection. We use our application icon as the icon for this item.
   // We remove '&' characters from this string so we can share it with our
   // system menu.
   scoped_refptr<ShellLinkItem> chrome(new ShellLinkItem);
@@ skipping 14 matching lines @@
       UTF16ToWide(l10n_util::GetStringUTF16(IDS_NEW_INCOGNITO_WINDOW));
   ReplaceSubstringsAfterOffset(&incognito_title, 0, L"&", L"");
   incognito->SetTitle(incognito_title);
   incognito->SetIcon(chrome_path, 0, false);
   AddShellLink(collection, chrome_path, chrome_switches, incognito);
 
   // We can now add the new list to the JumpList.
   // ICustomDestinationList::AddUserTasks() also uses the IObjectArray
   // interface to retrieve each item in the list. So, we retrieve the
   // IObjectArray interface from the EnumerableObjectCollection object.
-  ScopedComPtr<IObjectArray> object_array;
+  base::win::ScopedComPtr<IObjectArray> object_array;
   result = collection.QueryInterface(object_array.Receive());
   if (FAILED(result))
     return result;
 
   return list->AddUserTasks(object_array);
 }
 
 // Updates the application JumpList.
 // This function encapsulates all OS-specific operations required for updating
 // the Chromium JumpList, such as:
 // * Creating an ICustomDestinationList instance;
 // * Updating the categories of the ICustomDestinationList instance, and;
 // * Sending it to Taskbar of Windows 7.
 bool UpdateJumpList(const wchar_t* app_id,
                     const ShellLinkItemList& most_visited_pages,
                     const ShellLinkItemList& recently_closed_pages) {
   // JumpList is implemented only on Windows 7 or later.
   // So, we should return now when this function is called on earlier versions
   // of Windows.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return true;
 
   // Create an ICustomDestinationList object and attach it to our application.
-  ScopedComPtr<ICustomDestinationList> destination_list;
+  base::win::ScopedComPtr<ICustomDestinationList> destination_list;
   HRESULT result = destination_list.CreateInstance(CLSID_DestinationList, NULL,
                                                    CLSCTX_INPROC_SERVER);
   if (FAILED(result))
     return false;
 
   // Set the App ID for this JumpList.
   destination_list->SetAppID(app_id);
 
   // Start a transaction that updates the JumpList of this application.
   // This implementation just replaces the all items in this JumpList, so
   // we don't have to use the IObjectArray object returned from this call.
   // It seems Windows 7 RC (Build 7100) automatically checks the items in this
   // removed list and prevent us from adding the same item.
   UINT max_slots;
-  ScopedComPtr<IObjectArray> removed;
+  base::win::ScopedComPtr<IObjectArray> removed;
   result = destination_list->BeginList(&max_slots, __uuidof(*removed),
                                        reinterpret_cast<void**>(&removed));
   if (FAILED(result))
     return false;
 
   // Retrieve the absolute path to "chrome.exe".
   FilePath chrome_path;
   if (!PathService::Get(base::FILE_EXE, &chrome_path))
     return false;
 
@@ skipping 347 matching lines @@
   // the file thread.
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       new JumpListUpdateTask(app_id_.c_str(), icon_dir_, most_visited_pages_,
                              recently_closed_pages_));
 
   // Delete all items in these lists since we don't need these lists any longer.
   most_visited_pages_.clear();
   recently_closed_pages_.clear();
 }