Fix generate_profile.

chrome/tools/profiles/generate_profile.cc

 // Copyright (c) 2012 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.
 
 // This program generates a user profile and history by randomly generating
 // data and feeding it to the history service.
 
 #include "chrome/tools/profiles/thumbnail-inl.h"
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/i18n/icu_util.h"
+#include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/thumbnail_score.h"
+#include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_paths.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 
+#if defined(TOOLKIT_GTK)
+#include <gtk/gtk.h>
+#endif
+
 using base::Time;
 using content::BrowserThread;
 
 // Addition types data can be generated for. By default only urls/visits are
 // added.
 enum Types {
   TOP_SITES = 1 << 0,
   FULL_TEXT = 1 << 1
 };
 
+// RAII for initializing and shutting down the TestBrowserProcess
+class InitBrowserProcess {
+ public:
+  InitBrowserProcess() {
+    DCHECK(!g_browser_process);
+    g_browser_process = new TestingBrowserProcess;
+  }
+
+  ~InitBrowserProcess() {
+    DCHECK(g_browser_process);
+    delete g_browser_process;
+    g_browser_process = NULL;
+  }
+};
+
 // Probabilities of different word lengths, as measured from Darin's profile.
 //   kWordLengthProbabilities[n-1] = P(word of length n)
 const float kWordLengthProbabilities[] = { 0.069f, 0.132f, 0.199f,
   0.137f, 0.088f, 0.115f, 0.081f, 0.055f, 0.034f, 0.021f, 0.019f, 0.018f,
   0.007f, 0.007f, 0.005f, 0.004f, 0.003f, 0.003f, 0.003f };
 
 // Return a float uniformly in [0,1].
 // Useful for making probabilistic decisions.
 float RandomFloat() {
   return rand() / static_cast<float>(RAND_MAX);
 }
 
 // Return an integer uniformly in [min,max).
 int RandomInt(int min, int max) {
   return min + (rand() % (max-min));
 }
 
 // Return a string of |count| lowercase random characters.
-std::wstring RandomChars(int count) {
-  std::wstring str;
+string16 RandomChars(int count) {
+  string16 str;
   for (int i = 0; i < count; ++i)
     str += L'a' + rand() % 26;
   return str;
 }
 
-std::wstring RandomWord() {
+string16 RandomWord() {
   // TODO(evanm): should we instead use the markov chain based
   // version of this that I already wrote?
 
   // Sample a word length from kWordLengthProbabilities.
   float sample = RandomFloat();
-  int i;
+  size_t i;
   for (i = 0; i < arraysize(kWordLengthProbabilities); ++i) {
     sample -= kWordLengthProbabilities[i];
     if (sample < 0) break;
   }
   const int word_length = i + 1;
   return RandomChars(word_length);
 }
 
 // Return a string of |count| random words.
-std::wstring RandomWords(int count) {
-  std::wstring str;
+string16 RandomWords(int count) {
+  string16 str;
   for (int i = 0; i < count; ++i) {
     if (!str.empty())
       str += L' ';
     str += RandomWord();
   }
   return str;
 }
 
 // Return a random URL-looking string.
 GURL ConstructRandomURL() {
-  return GURL(std::wstring(L"http://") + RandomChars(3) + L".com/" +
+  return GURL(ASCIIToUTF16("http://") + RandomChars(3) + ASCIIToUTF16(".com/") +
       RandomChars(RandomInt(5, 20)));
 }
 
 // Return a random page title-looking string.
-std::wstring ConstructRandomTitle() {
+string16 ConstructRandomTitle() {
   return RandomWords(RandomInt(3, 15));
 }
 
 // Return a random string that could function as page contents.
-std::wstring ConstructRandomPage() {
+string16 ConstructRandomPage() {
   return RandomWords(RandomInt(10, 4000));
 }
 
 // Insert a batch of |batch_size| URLs, starting at pageid |page_id|.
 void InsertURLBatch(Profile* profile,
                     int page_id,
                     int batch_size,
                     int types) {
   HistoryService* history_service =
       HistoryServiceFactory::GetForProfile(profile, Profile::EXPLICIT_ACCESS);
@@ skipping 69 matching lines @@
       top_sites->SetPageThumbnail(url, image, score);
     }
 
     previous_url = url;
 
     if (revisit_urls.empty() || RandomFloat() < kRevisitableURLProbability)
       revisit_urls.push_back(url);
   }
 }
 
-int main(int argc, const char* argv[]) {
+int main(int argc, char* argv[]) {
   CommandLine::Init(argc, argv);
   base::EnableTerminationOnHeapCorruption();
   base::AtExitManager exit_manager;
   CommandLine* cl = CommandLine::ForCurrentProcess();
 
   int types = 0;
   if (cl->HasSwitch("top-sites"))
     types |= TOP_SITES;
   if (cl->HasSwitch("full-text"))
     types |= FULL_TEXT;
 
   // We require two arguments: urlcount and profiledir.
   const CommandLine::StringVector& args = cl->GetArgs();
   if (args.size() < 2) {
     printf("usage: %s [--top-sites] [--full-text] <urlcount> "
            "<profiledir>\n", argv[0]);
     printf("\n  --top-sites Generate thumbnails\n");
     printf("\n  --full-text Generate full text index\n");
     return -1;
   }
 
   int url_count = 0;
-  base::StringToInt(WideToUTF8(args[0]), &url_count);
+  base::StringToInt(args[0], &url_count);
   FilePath dst_dir(args[1]);
   if (!dst_dir.IsAbsolute()) {
     FilePath current_dir;
     file_util::GetCurrentDirectory(&current_dir);
     dst_dir = current_dir.Append(dst_dir);
   }
   if (!file_util::CreateDirectory(dst_dir)) {
-    printf("Unable to create directory %ls: %d\n",
-           dst_dir.value().c_str(),
-           ::GetLastError());
+    PLOG(ERROR) << "Unable to create directory " << dst_dir.value().c_str();
   }
 
   icu_util::Initialize();
+  // Copied from base/test/test_suite.cc.
+#if defined(TOOLKIT_GTK)
+  gtk_init_check(&argc, &argv);
+#endif
 
+  InitBrowserProcess initialize_browser_process;
   chrome::RegisterPathProvider();
   ui::RegisterPathProvider();
-  ResourceBundle::InitSharedInstanceWithLocale("en-US", NULL);
-  scoped_ptr<content::NotificationService> notification_service(
-      content::NotificationService::Create());
   MessageLoopForUI message_loop;
   content::BrowserThreadImpl ui_thread(BrowserThread::UI, &message_loop);
   content::BrowserThreadImpl db_thread(BrowserThread::DB, &message_loop);
+  ResourceBundle::InitSharedInstanceWithLocale("en-US", NULL);
   TestingProfile profile;
   profile.CreateHistoryService(false, false);
   if (types & TOP_SITES) {
     profile.CreateTopSites();
     profile.BlockUntilTopSitesLoaded();
   }
 
   srand(static_cast<unsigned int>(Time::Now().ToInternalValue()));
 
   // The maximum number of URLs to insert into history in one batch.
@@ skipping 13 matching lines @@
   profile.DestroyHistoryService();
 
   message_loop.RunUntilIdle();
 
   file_util::FileEnumerator file_iterator(profile.GetPath(), false,
       file_util::FileEnumerator::FILES);
   FilePath path = file_iterator.Next();
   while (!path.empty()) {
     FilePath dst_file = dst_dir.Append(path.BaseName());
     file_util::Delete(dst_file, false);
-    printf("Copying file %ls to %ls\n", path.value().c_str(),
+    printf("Copying file %" PRFilePath " to "
+           "%" PRFilePath "\n", path.value().c_str(),
            dst_file.value().c_str());
     if (!file_util::CopyFile(path, dst_file)) {
-      printf("Copying file failed: %d\n", ::GetLastError());
+      PLOG(ERROR) << "Copying file failed";
       return -1;
     }
     path = file_iterator.Next();
   }
 
   return 0;
 }