Add more scaffolding to make shared linking work.

chrome/common/temp_scaffolding_stubs.cc

 // Copyright (c) 2009 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 "temp_scaffolding_stubs.h"
 
+#include "build/build_config.h"
+
+#include <vector>
+
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/thread.h"
 #include "base/path_service.h"
 #include "base/string_piece.h"
 #include "base/singleton.h"
 #include "base/task.h"
-#include "build/build_config.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/autocomplete/history_url_provider.h"
+#include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/cache_manager_host.h"
 #include "chrome/browser/debugger/debugger_shell.h"
 #include "chrome/browser/first_run.h"
 #include "chrome/browser/history/in_memory_history_backend.h"
 #include "chrome/browser/memory_details.h"
 #include "chrome/browser/profile_manager.h"
 #include "chrome/browser/renderer_host/render_widget_helper.h"
 #include "chrome/browser/renderer_host/resource_message_filter.h"
@@ skipping 18 matching lines @@
 
 // static
 size_t AutocompleteProvider::max_matches_;
 
 AutocompleteProvider::~AutocompleteProvider() {
   // Though nothing needs this function yet, we want to get the C++ metadata
   // for this class grounded in this file.
   NOTIMPLEMENTED();
 }
 
+std::wstring AutocompleteProvider::StringForURLDisplay(const GURL& url,
+                                                       bool check_accept_lang) {
+  NOTIMPLEMENTED();
+  return L"";
+}
+
 // static
 size_t AutocompleteResult::max_matches_;
 
 //static
 std::string AutocompleteInput::TypeToString(AutocompleteInput::Type type) {
   NOTIMPLEMENTED();
   return "";
 }
 
+AutocompleteMatch::AutocompleteMatch(AutocompleteProvider* provider,
+                                     int relevance,
+                                     bool deletable,
+                                     Type type) {
+  NOTIMPLEMENTED();
+}
+
 //static
 std::string AutocompleteMatch::TypeToString(AutocompleteMatch::Type type) {
   NOTIMPLEMENTED();
   return "";
 }
 
+void AutocompleteMatch::ClassifyLocationInString(
+    size_t match_location,
+    size_t match_length,
+    size_t overall_length,
+    int style,
+    ACMatchClassifications* classification) {
+  NOTIMPLEMENTED();
+}
+
 //--------------------------------------------------------------------------
 
 UserDataManager* UserDataManager::instance_ = NULL;
 
 UserDataManager* UserDataManager::Create() {
   DCHECK(!instance_);
   std::wstring user_data;
   PathService::Get(chrome::DIR_USER_DATA, &user_data);
   instance_ = new UserDataManager(user_data);
   return instance_;
@@ skipping 268 matching lines @@
 namespace chrome_browser_net {
 
 void EnableDnsPrefetch(bool) { NOTIMPLEMENTED(); }
 
 void DnsPrefetchList(const std::vector<std::string>& hostnames) {
   NOTIMPLEMENTED();
 }
 
 void SaveHostNamesForNextStartup(PrefService* local_state) { NOTIMPLEMENTED(); }
 
+void DnsPrefetchGetHtmlInfo(std::string* output) { NOTIMPLEMENTED(); }
+
 }  // namespace chrome_browser_net
 
 //--------------------------------------------------------------------------
 
 // This is from chrome_plugin_util.cc.
 void CPB_Free(void* memory) { NOTIMPLEMENTED(); }
 
 //--------------------------------------------------------------------------
 
 void RunJavascriptMessageBox(WebContents* web_contents,
@@ skipping 93 matching lines @@
 #endif  // !CHROME_DEBUGGER_DISABLED
 
 void HistoryURLProvider::ExecuteWithDB(history::HistoryBackend*,
                                        history::URLDatabase*,
                                        HistoryURLProviderParams*) {
   NOTIMPLEMENTED();
 }
 
 namespace bookmark_utils {
 
-bool MoreRecentlyAdded(BookmarkNode* n1, BookmarkNode* n2) {
+bool DoesBookmarkContainText(BookmarkNode* node, const std::wstring& text) {
   NOTIMPLEMENTED();
   return false;
 }
 
+void GetMostRecentlyAddedEntries(BookmarkModel* model,
+                                 size_t count,
+                                 std::vector<BookmarkNode*>* nodes) {
+  NOTIMPLEMENTED();
+}
+
 std::vector<BookmarkNode*> GetMostRecentlyModifiedGroups(BookmarkModel* model,
                                                          size_t max_count) {
   NOTIMPLEMENTED();
   return std::vector<BookmarkNode*>();
 }
 
+void GetBookmarksContainingText(BookmarkModel* model,
+                                const std::wstring& text,
+                                size_t max_count,
+                                std::vector<BookmarkNode*>* nodes) {
+  NOTIMPLEMENTED();
+}
+
+void GetBookmarksMatchingText(BookmarkModel* model,
+                              const std::wstring& text,
+                              size_t max_count,
+                              std::vector<TitleMatch>* matches) {
+  NOTIMPLEMENTED();
+}
+
+bool MoreRecentlyAdded(BookmarkNode* n1, BookmarkNode* n2) {
+  NOTIMPLEMENTED();
+  return false;
+}
+
 }
 
 ScopableCPRequest::~ScopableCPRequest() {
   NOTIMPLEMENTED();
 }
 
 #if defined(OS_MACOSX)
 namespace gfx {
 std::wstring GetCleanStringFromUrl(const GURL& url,
                                    const std::wstring& languages,
@@ skipping 20 matching lines @@
 
 InfoBar* AlertInfoBarDelegate::CreateInfoBar() {
   NOTIMPLEMENTED();
   return NULL;
 }
 
 InfoBar* LinkInfoBarDelegate::CreateInfoBar() {
   NOTIMPLEMENTED();
   return NULL;
 }
+
+bool CanImportURL(const GURL& url) {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool DOMUIContentsCanHandleURL(GURL* url,
+                               TabContentsType* result_type) {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool NewTabUIHandleURL(GURL* url,
+                       TabContentsType* result_type) {
+  NOTIMPLEMENTED();
+  return false;
+}