Add extensions code to use common updater in components/update_client/

extensions/browser/extensions_browser_client.cc

 // Copyright 2013 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 "extensions/browser/extensions_browser_client.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
+#include "components/update_client/update_client.h"
 #include "extensions/browser/extension_error.h"
+#include "extensions/browser/updater/update_client_config.h"
 
 namespace extensions {
 
 namespace {
 
 ExtensionsBrowserClient* g_client = NULL;
 
 }  // namespace
 
+scoped_refptr<update_client::UpdateClient>
+ExtensionsBrowserClient::CreateUpdateClient(content::BrowserContext* context) {
+  return scoped_refptr<update_client::UpdateClient>(nullptr);

[Sorin Jianu, 2015/10/02 00:05:10]

I assume that the  UpdateClientFactory call is not hooked up at this time. Is
that true?
Also, a configurator instance would be needed at this call site.

[asargent_no_longer_on_chrome, 2015/10/06 21:31:17]

This is just a default implementation so that some other ExtensionsBrowserClient
subclasses (like app_shell and some testing ones) don't have to have the same
boilerplate. 

There is an override of this method in ChromeExtensionsBrowserClient
(chrome/browser/extensions/chrome_extensions_browser_client.cc) in this CL which
actually does create an UpdateClient using UpdateClientFactory 

[Sorin Jianu, 2015/10/08 22:57:54]

I see. In the general case is not desirable to have this kind of implementation
but I assume that you've considered using composition instead of inheritance,
and this implementation is better.

[asargent_no_longer_on_chrome, 2015/10/14 17:04:31]

I think preferring composition to inheritance is a good general principle, but
most applicable to cases where the inherited class has interesting concrete
functionality in it. In this case the ExtensionsBrowserClient class is almost
entirely pure virtual, so it's pretty much just an abstract interface, and all
interesting concrete details are implemented in the concrete classes that
inherit from it, with the exception of a few uninteresting "do nothing" defaults
like this function and ExtensionsBrowserClient::ReportError below. 

[Sorin Jianu, 2015/10/14 20:37:09]

Acknowledged.

+}
+
 void ExtensionsBrowserClient::ReportError(content::BrowserContext* context,
                                           scoped_ptr<ExtensionError> error) {
   LOG(ERROR) << error->GetDebugString();
 }
 
 ExtensionsBrowserClient* ExtensionsBrowserClient::Get() {
   return g_client;
 }
 
 void ExtensionsBrowserClient::Set(ExtensionsBrowserClient* client) {
   g_client = client;
 }
 
 }  // namespace extensions