Handle null SuggestionsService in chrome://suggestions

chrome/browser/search/suggestions/suggestions_source.cc

 // Copyright 2014 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/search/suggestions/suggestions_source.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
@@ skipping 30 matching lines @@
 const char kHtmlFooter[] = "</body>\n</html>\n";
 
 const char kRefreshPath[] = "refresh";
 
 std::string GetRefreshHtml(bool is_refresh) {
   if (is_refresh)
     return "<p>Refreshing in the background, reload to see new data.</p>\n";
   return std::string("<p><a href=\"") + chrome::kChromeUISuggestionsURL +
          kRefreshPath + "\">Refresh</a></p>\n";
 }
-
-// Fills |output| with the HTML needed to display the suggestions.
-void RenderOutputHtml(bool is_refresh,
-                      const SuggestionsProfile& profile,
-                      const std::map<GURL, std::string>& base64_encoded_pngs,
-                      std::string* output) {
+// Returns the HTML needed to display the suggestions.
+std::string RenderOutputHtml(

[Marc Treib, 2016/03/29 12:14:26]

Unrelated cleanup: With C++11, there's no need to use an out param anymore :)

[Bernhard Bauer, 2016/03/29 12:31:47]

Hooray!

+    bool is_refresh,
+    const SuggestionsProfile& profile,
+    const std::map<GURL, std::string>& base64_encoded_pngs) {
   std::vector<std::string> out;
   out.push_back(kHtmlHeader);
   out.push_back(kHtmlBody);
   out.push_back("<h1>Suggestions</h1>\n");
   out.push_back(GetRefreshHtml(is_refresh));
   out.push_back("<ul>");
   int64_t now = (base::Time::NowFromSystemTime() - base::Time::UnixEpoch())
                     .ToInternalValue();
   size_t size = profile.suggestions_size();
   for (size_t i = 0; i < size; ++i) {
@@ skipping 20 matching lines @@
     line += base::UTF16ToUTF8(remaining_time_formatted);
     std::vector<std::string> providers;
     for (int p = 0; p < suggestion.providers_size(); ++p)
       providers.push_back(base::IntToString(suggestion.providers(p)));
     line += ". Provider IDs: " + base::JoinString(providers, ", ");
     line += "</li>\n";
     out.push_back(line);
   }
   out.push_back("</ul>");
   out.push_back(kHtmlFooter);
-  *output = base::JoinString(out, base::StringPiece());
+  return base::JoinString(out, base::StringPiece());
 }
 
-// Fills |output| with the HTML needed to display that no suggestions are
-// available.
-void RenderOutputHtmlNoSuggestions(bool is_refresh, std::string* output) {
+// Returns the HTML needed to display that no suggestions are available.
+std::string RenderOutputHtmlNoSuggestions(bool is_refresh) {
   std::vector<std::string> out;
   out.push_back(kHtmlHeader);
   out.push_back(kHtmlBody);
   out.push_back("<h1>Suggestions</h1>\n");
   out.push_back("<p>You have no suggestions.</p>\n");
   out.push_back(GetRefreshHtml(is_refresh));
   out.push_back(kHtmlFooter);
-  *output = base::JoinString(out, base::StringPiece());
+  return base::JoinString(out, base::StringPiece());
 }
 
 }  // namespace
 
 SuggestionsSource::SuggestionsSource(Profile* profile)
     : profile_(profile), weak_ptr_factory_(this) {}
 
 SuggestionsSource::~SuggestionsSource() {}
 
 SuggestionsSource::RequestContext::RequestContext(
@@ skipping 14 matching lines @@
 void SuggestionsSource::StartDataRequest(
     const std::string& path, int render_process_id, int render_frame_id,
     const content::URLDataSource::GotDataCallback& callback) {
   // If this was called as "chrome://suggestions/refresh", we also trigger an
   // async update of the suggestions.
   bool is_refresh = (path == kRefreshPath);
 
   SuggestionsService* suggestions_service =
       SuggestionsServiceFactory::GetForProfile(profile_);
 
+  // |suggestions_service| is null for guest profiles.
+  if (!suggestions_service) {
+    std::string output = RenderOutputHtmlNoSuggestions(is_refresh);
+    callback.Run(base::RefCountedString::TakeString(&output));
+    return;
+  }
+
   if (is_refresh)
     suggestions_service->FetchSuggestionsData();
 
   SuggestionsProfile suggestions_profile =
       suggestions_service->GetSuggestionsDataFromCache();
   size_t size = suggestions_profile.suggestions_size();
   if (!size) {
-    std::string output;
-    RenderOutputHtmlNoSuggestions(is_refresh, &output);
+    std::string output = RenderOutputHtmlNoSuggestions(is_refresh);
     callback.Run(base::RefCountedString::TakeString(&output));
   } else {
     RequestContext* context =
         new RequestContext(is_refresh, suggestions_profile, callback);
     base::Closure barrier = BarrierClosure(
         size, base::Bind(&SuggestionsSource::OnThumbnailsFetched,
                          weak_ptr_factory_.GetWeakPtr(), context));
     for (size_t i = 0; i < size; ++i) {
       const ChromeSuggestion& suggestion = suggestions_profile.suggestions(i);
       // Fetch the thumbnail for this URL (exercising the fetcher). After all
@@ skipping 15 matching lines @@
 
 base::MessageLoop* SuggestionsSource::MessageLoopForRequestPath(
     const std::string& path) const {
   // This can be accessed from the IO thread.
   return content::URLDataSource::MessageLoopForRequestPath(path);
 }
 
 void SuggestionsSource::OnThumbnailsFetched(RequestContext* context) {
   scoped_ptr<RequestContext> context_deleter(context);
 
-  std::string output;
-  RenderOutputHtml(context->is_refresh, context->suggestions_profile,
-                   context->base64_encoded_pngs, &output);
+  std::string output =
+      RenderOutputHtml(context->is_refresh, context->suggestions_profile,
+                       context->base64_encoded_pngs);
   context->callback.Run(base::RefCountedString::TakeString(&output));
 }
 
 void SuggestionsSource::OnThumbnailAvailable(RequestContext* context,
                                              base::Closure barrier,
                                              const GURL& url,
                                              const SkBitmap* bitmap) {
   if (bitmap) {
     std::vector<unsigned char> output;
     gfx::PNGCodec::EncodeBGRASkBitmap(*bitmap, false, &output);
 
     std::string encoded_output;
     base::Base64Encode(std::string(output.begin(), output.end()),
                        &encoded_output);
     context->base64_encoded_pngs[url] = "data:image/png;base64,";
     context->base64_encoded_pngs[url] += encoded_output;
   }
   barrier.Run();
 }
 
 }  // namespace suggestions